如何使Java线程始终在另一个线程之前运行？

Question

In my program, when a user enters a number, the program sends that number to the server through sockets and the server sends back data matching that number. The number represents a service level. The thread which has the IncomingReader() instance as its runnable then reads what was sent from the server, stores it an arraylist(details). I then create objects of class MyClients using the data in the details arraylist. My problem is that the loop which creates the objects runs before the thread that reads data from the server runs. How can I make the thread that reads from the server run before the loop that creates the objects? The code is as follows: (I've removed the code for the GUI for the sake of being concise)

public class SearchClients {

JFrame frame;
private JTextField textField;
private JTextField textField_1;
private JTextField textField_2;
private JTextField textField_3;


BufferedReader reader;
PrintWriter writer;
Socket sock;

 static ArrayList<String> details = new ArrayList<String>();

public static void main(String[] args) {
    EventQueue.invokeLater(new Runnable() {
        public void run() {
            try {
                SearchClients window = new SearchClients();
                window.frame.setVisible(true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
}

public SearchClients() {
    initialize();
}

private void initialize() {

    setUpNetworking();
    Thread readerThread = new Thread(new IncomingReader());
    readerThread.start();


    JButton btnSearchByService = new JButton("Search By Service Level");

    btnSearchByService.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            searchByServiceLevel();
        }
    });

}

public void searchByServiceLevel() {

    try {
        writer.println("SEARCH BY SERVICE LEVEL");
        writer.println(textField_1.getText());
        writer.flush();


    }
    catch (Exception ex) {
        ex.printStackTrace();
    }



    JPanel nameSearchPane = new JPanel(new BorderLayout());

    frame.setExtendedState(Frame.MAXIMIZED_BOTH);
    frame.setContentPane(nameSearchPane);
    frame.invalidate();
    frame.validate();

    String[] columns = {"Name", "Phone Number", "Address", "District", "County", "Village", "Installation Date", "Energy Store", "Service Level", "Account Balance", "Months Owed", "Next Payment Date"};

    ArrayList<MyClients> clientDetails = new ArrayList<MyClients>();
    for(int y = 0; y < details.size(); y++) {
        MyClients client = new MyClients();
        client.name = details.get(y);
        client.phone_number = details.get(++y);
        client.address = details.get(++y);
        client.district = details.get(++y);
        client.county = details.get(++y);
        client.village = details.get(++y);
        client.installation_date = details.get(++y);
        client.energy_store = details.get(++y);
        client.service_level = details.get(++y);
        client.next_payment_date = details.get(++y);
        client.account_balance = details.get(++y);
        client.months_owed = details.get(++y);
        clientDetails.add(client);

    }

    details.clear();

//      Check if any data was returned from the database
    if(clientDetails.isEmpty()) {
        JOptionPane.showMessageDialog(frame, "A client with that service level was not found.\n Try service level: 1, 2, 3 or 4.");

        frame.setVisible(false);
        SearchClients search = new SearchClients();
        search.frame.setVisible(true);
    }

    String[][] clients = new String[100][100];

    for(int x = 0; x < clientDetails.size(); x++) {
        clients[x][0] = clientDetails.get(x).name;
        clients[x][1] = clientDetails.get(x).phone_number;
        clients[x][2] = clientDetails.get(x).address;
        clients[x][3] = clientDetails.get(x).district;
        clients[x][4] = clientDetails.get(x).county;
        clients[x][5] = clientDetails.get(x).village;
        clients[x][6] = clientDetails.get(x).installation_date.toString();
        clients[x][7] = clientDetails.get(x).energy_store;
        clients[x][8] = clientDetails.get(x).service_level;
        clients[x][9] = clientDetails.get(x).account_balance;
        clients[x][10] = clientDetails.get(x).months_owed;
        clients[x][11] = clientDetails.get(x).next_payment_date.toString(); 

    }

    JTable table = new JTable(clients, columns);
    JScrollPane tableContainer = new JScrollPane(table);
    nameSearchPane.add(tableContainer, BorderLayout.CENTER);

}

private void setUpNetworking() {
    try {
        sock = new Socket("127.0.0.1", 5000);
        InputStreamReader streamReader = new InputStreamReader(
                sock.getInputStream());
        reader = new BufferedReader(streamReader);
        writer = new PrintWriter(sock.getOutputStream());
        System.out.println("Networking established");
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}


class IncomingReader implements Runnable {
    public void run() {
        String message;
        try {
            while ((message = reader.readLine()) != null) {
                details.add(message);

            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

class MyClients {
    String name = "";
    String phone_number = "";
    String address = "";
    String district = "";
    String county = "";
    String village = "";
    String installation_date = "";
    String energy_store = "";
    String service_level = "";
    String next_payment_date = "";
    String account_balance = "";
    String months_owed = "";
    String clientID = "";
}

}

Answer 1

Why do you have them in separate threads?

Usually, if the execution of B relies on the execution of A, then having A and B in separate threads is overhead you don't need, they are effectively sequential.

Now that's out of the way, it looks like you're trying to write a server. Typically, you'd run the "server" as its own application. It would open a socket, and wait for input. On input, it'd spin up a worker thread (so that the server can continue to receive connections on the socket). And then send the information back via the socket to the calling program. The calling program sends information to the server, and "waits" until the information comes back.

So there's a few things you probably want to do.

• you probably want to have your "threads" be actual different applications

• you need to "wait" in your sending thread either by:

  • some form of block on the communication response
  • a callback object which can be invoked on response
  • something in your application loop which queries for a response.

As a final comment, at any point you need to run thread A before thread B, you're doing your threading wrong. and need to stop and look at why :)

Answer 2

How can I make the thread that reads from the server run before the loop that creates the objects?

This has nothing to do with thread "order of running" and everything to do with state of the object . In fact your focusing on thread order I think has prevented you from thinking of the true nature of your problem. You need to make your program behave appropriately to incoming data depending on its state which changes depending on what is received and what it is doing. Now on to what specific state problem you have:

Producer-Consumer Problem:

Yours is a classic producer-consumer problem, and so what you want to do is not use an ArrayList of details but rather a Queue. Properly used, the consumer, your client, and its object production loop will be blocked when the queue of Details is empty and will wait for Details to arrive before creating objects.

As an aside, whatever collection or technique you use, your collection of Details should absolutely not be static . This will limit your ability to use the collection and associated methods in any OOP fashion.

Answer 3

You can use the join method of class Thread . It will wait until the thread completes execution and then return. After that, you can start the second thread.

Answer 4

I am not sure how you can make sure A always run before B, but there is a method of making sure B always run after A.

Using CountDownLatch .

See following example modified on this , The main thread will wait and block until cacheService thread started .

    public class CountDownLatchDemo {

    public static void main(String args[]) {
       final CountDownLatch latch = new CountDownLatch(1);
       Thread cacheService = new Thread(new Service("CacheService", 1000, latch));       
       cacheService.start(); //separate thread will initialize CacheService

       try{
            latch.await();  //main thread is waiting on CountDownLatch to finish
            System.out.println("All services are up, Application is starting now");
       }catch(InterruptedException ie){
           ie.printStackTrace();
       }

    }

}

/**
 * Service class which will be executed by Thread using CountDownLatch synchronizer.
 */
class Service implements Runnable{
    private final String name;
    private final int timeToStart;
    private final CountDownLatch latch;

    public Service(String name, int timeToStart, CountDownLatch latch){
        this.name = name;
        this.timeToStart = timeToStart;
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(timeToStart);
        } catch (InterruptedException ex) {
            Logger.getLogger(Service.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println( name + " is Up");
        latch.countDown(); //reduce count of CountDownLatch by 1
    }

}

Output:
CacheService is Up
All services are up, Application is starting now