जावा

Question

के लिए धागे में सिंक्रनाइज़ेशन मेरे पास मेरे ऐप में एक घर उगाया गया वेब सर्वर है। यह वेब सर्वर स्वीकार्य होने के लिए सॉकेट में आने वाले प्रत्येक अनुरोध के लिए एक नया धागा बनाता है। मैं चाहता हूं कि वेब सर्वर तब तक इंतजार करे जब तक कि उस थ्रेड में एक विशिष्ट बिंदु हिट न हो जाए।

मैं इस साइट पर कई पोस्ट और वेब पर उदाहरणों के माध्यम से रहा हूं, लेकिन थ्रेड को प्रतीक्षा करने के बाद वेब सर्वर आगे बढ़ने के लिए नहीं मिल सकता। एक बुनियादी कोड उदाहरण बहुत अच्छा होगा।

क्या सिंक्रनाइज़ किए गए कीवर्ड को इसके बारे में जाने का सही तरीका है? यदि हां, तो यह कैसे प्राप्त किया जा सकता है? कोड उदाहरण मेरे ऐप्लिकेशन के नीचे हैं:

वेब सर्वर

while (true) { 
    //block here until a connection request is made 
    socket = server_socket.accept(); 

    try { 
    //create a new HTTPRequest object for every file request 
    HttpRequest request = new HttpRequest(socket, this); 

    //create a new thread for each request 
    Thread thread = new Thread(request); 

    //run the thread and have it return after complete 
    thread.run(); 

    /////////////////////////////// 
    wait here until notifed to proceed 
    /////////////////////////////// 
    } catch (Exception e) { 
    e.printStackTrace(logFile); 
    } 
} 

थ्रेड कोड

public void run() { 
    //code here 

    //notify web server to continue here 
} 

अद्यतन - अंतिम कोड के रूप में नीचे है। HttpRequest सिर्फ resumeListener.resume() फोन करता है जब भी मैं एक प्रतिक्रिया हेडर भेज (बेशक एक अलग वर्ग के रूप में इंटरफेस और HttpRequest में addResumeListener(ResumeListener r1) विधि जोड़ने):

वेब सर्वर भाग

// server infinite loop 
while (true) { 

    //block here until a connection request is made 
    socket = server_socket.accept(); 

    try { 
    final Object locker = new Object(); 

    //create a new HTTPRequest object for every file request 
    HttpRequest request = new HttpRequest(socket, this); 

    request.addResumeListener(new ResumeListener() { 
     public void resume() { 
     //get control of the lock and release the server 
     synchronized(locker) { 
      locker.notify(); 
     } 
     } 
    }); 

    synchronized(locker) { 
     //create a new thread for each request 
     Thread thread = new Thread(request); 

     //run the thread and have it return after complete 
     thread.start(); 

     //tell this thread to wait until HttpRequest releases 
     //the server 
     locker.wait(); 
    } 
    } catch (Exception e) { 
    e.printStackTrace(Session.logFile); 
    } 
} 

Answer 1

सबसे पहले, मैं दूसरों की भावना को प्रतिबिंबित करता हूं कि यहां पहिया का पुन: आविष्कार करने से आपके लिए कई प्रकार के मुद्दों का कारण बन जाएगा। हालांकि, अगर आप इस सड़क पर जाना चाहते हैं वैसे भी जो आप करने की कोशिश कर रहे हैं वह मुश्किल नहीं है। क्या आपने जेटी के साथ प्रयोग किया है?

हो सकता है कि कुछ इस तरह:

public class MyWebServer { 

    public void foo() throws IOException { 
    while (true) { 
     //block here until a connection request is made 
     ServerSocket socket = new ServerSocket(); 

     try { 
     final Object locker = new Object(); 
     //create a new HTTPRequest object for every file request 
     MyRequest request = new MyRequest(socket); 
     request.addResumeListener(new ResumeListener() { 
      public void resume() { 
      locker.notify(); 
      } 
     }); 
     synchronized(locker){ 

      //create a new thread for each request 
      Thread thread = new Thread(request); 

      //start() the thread - not run() 
      thread.start(); 

      //this thread will block until the MyRequest run method calls resume 
      locker.wait(); 
     } 
     } catch (Exception e) { 
     } 

    } 
    } 
} 

public interface ResumeListener { 
    public void resume(); 
} 

public class MyRequest implements Runnable{ 
    private ResumeListener resumeListener; 

    public MyRequest(ServerSocket socket) { 
    } 

    public void run() { 
    // do something 
    resumeListener.resume(); //notify server to continue accepting next request 
    } 

    public void addResumeListener(ResumeListener rl) { 
    this.resumeListener = rl; 
    } 
} 

Answer 2

आप उपयोग कर सकते हैं java.util.concurrent.CountDownLatch इसके लिए 1 की गिनती के साथ। माता-पिता और बच्चे धागे द्वारा बनाए और साझा किए जाने के उदाहरण के लिए व्यवस्थित करें (उदाहरण के लिए, इसे HttpRequest के निर्माता में बनाएं, और इसे किसी सदस्य फ़ंक्शन द्वारा पुनः प्राप्त करने योग्य बनाएं)। सर्वर तब await() पर कॉल करता है, और थ्रेड countDown() हिट करता है जब यह अपने माता-पिता को रिलीज़ करने के लिए तैयार होता है।

Answer 3

आपको शायद जावा Condition का उपयोग करने की आवश्यकता है। डॉक्स से:

शर्तें (भी हालत के रूप में जाना कतारों या हालत चर) एक साधन प्रदान एक थ्रेड के लिए एक और धागा द्वारा ("प्रतीक्षा" के लिए) निष्पादन अधिसूचित जब तक निलंबित करने के लिए है कि कुछ राज्य हालत अब सच हो सकता है।

Answer 4

डीबगर के तहत भागो और ब्रेकपॉइंट सेट करें?

यदि असुरक्षित है, तो System.in से एक लाइन पढ़ें?