Question

请告诉我如何让线程等待。例如，等待i == 0并在i == 1

时再次转到

public class Main {

    public Main() { 
    }

    public void method() {

            Thread thread = new Thread(new Task());
            // I want to make wait it when I want
            // for example wait if i == 0 and go again when i = 1
    }

    public static void main(String[] args) {
            new Main();
    }
}

Answer 1

这适用于CountDownLatch。

    public static void main( String[] args ) throws Exception {
    final CountDownLatch latch = new CountDownLatch( 1 );
    System.out.println( "Starting main thread" );
    new Thread( new Runnable() {
        public void run() {
            System.out.println( "Starting second thread" );
            System.out.println( "Waiting in second thread" );
            try {
                latch.await();
            } catch ( InterruptedException e ) {
                e.printStackTrace();
            }
            System.out.println( "Stopping second thread" );
        }
    } ).start();

    Thread.sleep( 5000 );
    System.out.println( "Countdown in main thread" );
    latch.countDown();

    Thread.sleep( 1000 );
    System.out.println( "Stopping main thread" );
}

Answer 2

您可以使用semaphore

执行此操作

Answer 3

使用这样的标记不一定是最好的方法，但要回答您的具体问题：您可以创建int volatile。请参阅下面的一个简单示例，您可以按原样运行 - i为volatile这一事实对此至关重要。

输出是（由于线程交错，它可能与运行不同）：

i=1
I'm doing something
I'm doing something
i=0
I'm waiting
I'm waiting
i=1
I'm doing something
I'm doing something
I'm doing something
i=0
I'm waiting
I'm waiting
interrupting
I was interrupted: bye bye

public class TestThread {

    private static volatile int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Runnable r = new Runnable() {

            @Override
            public void run() {
                try {
                    while (true) {
                        while (i == 1) {
                            System.out.println("I'm doing something");
                            Thread.sleep(5);
                        }

                        while (i == 0) {
                            System.out.println("I'm waiting");
                            Thread.sleep(5);
                        }

                    }
                } catch (InterruptedException ex) {
                    System.out.println("I was interrupted: bye bye");
                    return;
                }
            }
        };

        Thread t = new Thread(r);
        t.start();

        i = 1;
        System.out.println("i=1");
        Thread.sleep(10);
        i = 0;
        System.out.println("i=0");
        Thread.sleep(10);
        i = 1;
        System.out.println("i=1");

        Thread.sleep(10);
        i = 0;
        System.out.println("i=0");
        Thread.sleep(10);
        t.interrupt();
        System.out.println("interrupting");
    }
}

Answer 4

要避免主动等待，请尝试使用wait()和notify()或notifyAll()方法。 Wait（）可以使线程停止，直到有人在等待的同一对象上调用 notify（）或 notifyAll（） （）。其中一个条件是线程必须拥有对象监视器，其中将调用 wait（）， notify（）或 notifyAll的（）的。

这是一个例子

import java.util.concurrent.TimeUnit;

public class StartPauseDemo extends Thread {
    volatile int i = 1;

    public void pause() {
        i = 0;
    }

    public synchronized void unPause() {
        i = 1;
        notify();// wake up thread
    }

    @Override
    public void run() {
        while (i==1) {
            // logic of method for example printing time every 200 miliseconds
            System.out.println(System.currentTimeMillis());
            try {
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (i==0) {
                synchronized (this) {// thread must possess monitor of object on
                                        // which will be called wait() method,
                                        // in our case current thread object
                    try {
                        wait();// wait until someone calls notify() or notifyAll
                                // on this thred object
                                // (in our case it is done in unPause() method)
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    // test - pausing and unpausing every 1 sec
    public static void main(String[] args) throws InterruptedException {
        StartPauseDemo sp = new StartPauseDemo();
        sp.start();// start thread
        while (true) {
            System.out.println("pausing");
            sp.pause();
            TimeUnit.SECONDS.sleep(1);

            System.out.println("unpausing");
            sp.unPause();
            TimeUnit.SECONDS.sleep(1);
        }
    }
}

输出：

pausing
unpausing
1338726153307
1338726153507
1338726153709
1338726153909
1338726154109
pausing
unpausing
1338726155307
1338726155507
... and so on

让线程等待

4 个答案: