Java中run(), start(), join(), wait(), yield(), sleep()的使用

Run

每个Thread中需要实现的方法, 如果直接调用的话, 会是和单线程一样的效果, 要另起线程需要使用start().

start

新起线程调用run(). 主线程不等待直接往下执行

Yield

Yield会告诉jvm, 它愿意让出当前的处理器使用, 让其他线程被执行. 这意味着它并非在执行非常紧急的任务, 这只是一个hit, 可能会被忽略, 可能并不会发生任何作用. 需要有详细的profiling和benchmarking来保证这个调用达到预期的效果.

• Yield是一个静态和原生的方法
• Yield告诉当前线程, 给予线程池中同等优先级的其他线程被执行的机会.
• Yield并不保证会立即将当前正在执行的线程状态转变为runnable.
• Yield只会将一个线程的状态从Running变成Runnable, 而不是wait或blocked状态.

Join

• 线程实例的join调用, 可以让这个线程执行的开始被关联到另一个线程执行的结束上, 这样直到另一个线程结束后这个线程才会开始执行. 如果对一个线程调用了join, 那么当前running的线程会被block, 直到那个线程执行结束.
• 如果在join中设置了timeout, 那么在timeout后会取消join, 当timeout时, 主线程会变成和任务线程一样的执行候选, 但是这个时间准确度取决于操作系统, 并不能保证是精确的.
• join和sleep一样, 会相应interrupt并抛出一个InterruptedException

如果有一个Thread a, 在a.start()后面(可以使用thread.isAlive()判断). 使用a.join() 可以使主线程等待a执行完. 如果同时有多个线程a, b, c, 而d需要等abc执行完后才能执行, 可以在d start之前使用a.join, b.join, c.join, 也可以把a, b, c的start放到d的run方法里面, 使用a.join, b.join, c.join, 可以用参数设置timeout时间.

class JoiningThread extends Thread {
    // NOTE: UNTESTED!
    private String name;
    private Thread nextThread;
 
    public JoiningThread(String name) {
        this(name, null);
    }
 
    public JoiningThread(String name, Thread other) {
        this.name = name;
        this.nextThread = other;
    }
 
    public String getName() {
        return name;
    }
 
    @Override
    public void run() {
        System.out.println("Hello I'm thread ".concat(getName()));
        if (nextThread != null) {
            while(nextThread.isAlive()) {
                try {
                    nextThread.join();
                } catch (InterruptedException e) {
                    // ignore this
                }
            }
        }
        System.out.println("I'm finished ".concat(getName()));
    }
}

使用的时候

public static void main(String[] args) {
    Thread d = WaitingThread("d");
    Thread c = WaitingThread("c", d);
    Thread b = WaitingThread("b", c);
    Thread a = WaitingThread("a", b);
 
    a.start();
    b.start();
    c.start();
    d.start();
 
    try {
        a.join();
    } catch (InterruptedException e) {}
}

sleep(): 需要时间作为参数, 可以被interrupt.

wait(): wait会释放当前持有的锁, 并进入sleep状态. 和join()的区别是, wait需要额外的notify来终止.

notify(): synchronized锁定的是什么资源, 就在什么资源上调用notify. notify会唤醒在当前锁定对象上使用了wait()的一个线程. 要注意的是, 调用notify时并未释放锁定的对象资源, 它只是告诉等待的线程, 你可以醒过来了. 而锁的释放要等到synchronized代码块执行的结束. 所以如果对一个资源调用了notify(), 而调用者本身还需要10秒中才能完成synchronized的代码块, 被唤醒的线程还需要再等10秒才能继续执行.

notifyAll(): 会唤醒当前锁定对象上等待的所有线程, 最高优先级的线程会拿到对象锁并继续执行(这不是完全保证的). 其他和notify是一样的.

上面的类可以改写为

class WaitingThread extends Thread {
    // NOTE: UNTESTED!
 
    private Thread previousThread;
    private String name;
 
    public WaitingThread(String name) {
        this(name, null);
    }
 
    public WaitingThread(String name, Thread other) {
        this.name = name;
        this.previousThread = other;
    }
 
    public String getName() {
        return name;
    }
 
    @Override
    public void run() {
        System.out.println("Hello I'm thread ".concat(getName()));
        // Do other things if required
 
        // Wait to be woken up
        while(true) {
            synchronized(this) {
                try {
                    wait();
                    break;
                } catch (InterruptedException e) {
                    // ignore this
                }
            }
        }
 
        System.out.println("I'm finished ".concat(getName()));
 
        // Wake up the previous thread
        if (previousThread != null) {
            synchronized(previousThread) {
                previousThread.notify();
            }
        }
    }
}

对于 synchronized, wait 和 notifyAll 的测试. 其中Producer模拟一个队列生产者, Consumer1和Consumer2模拟队列消费者, 队列是同步对象, 得到锁的线程, 会通过wait()或notifyAll()通知其他线程继续尝试得到锁.

Producer.java 

class Producer implements Runnable {
    private final List<Integer> taskQueue;
    private final int MAX_CAPACITY;
 
    public Producer(List<Integer> sharedQueue, int size) {
        this.taskQueue = sharedQueue;
        this.MAX_CAPACITY = size;
    }
 
    @Override
    public void run() {
        int counter = 0;
        while (true) {
            try {
                produce(counter++);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
 
    private void produce(int i) throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + ": produce()");
        synchronized (taskQueue) {
            System.out.println(Thread.currentThread().getName() + ": produce().synchronized >>");
            while (taskQueue.size() == MAX_CAPACITY) {
                System.out.println(Thread.currentThread().getName() + ": produce().synchronized ||");
                taskQueue.wait();
            }
 
            Thread.sleep(500 + (long)(Math.random() * 500));
            taskQueue.add(i);
            System.out.println(Thread.currentThread().getName() + ": Produced: " + i);
            taskQueue.notifyAll();
            System.out.println(Thread.currentThread().getName() + ": produce().synchronized <<");
        }
    }
}

Consumer.java

class Consumer implements Runnable {
    private final List<Integer> taskQueue;
 
    public Consumer(List<Integer> sharedQueue) {
        this.taskQueue = sharedQueue;
    }
 
    @Override
    public void run() {
        while (true) {
            try {
                consume();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
 
    private void consume() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + ": consume()");
        synchronized (taskQueue) {
            System.out.println(Thread.currentThread().getName() + ": consume().synchronized >>");
            while (taskQueue.isEmpty()) {
                System.out.println(Thread.currentThread().getName() + ": consume().synchronized ||");
                taskQueue.wait();
            }
            Thread.sleep(500 + (long)(Math.random() * 500));
            int i = (Integer) taskQueue.remove(0);
            System.out.println(Thread.currentThread().getName() + ": Consumed: " + i);
            taskQueue.notifyAll();
            System.out.println(Thread.currentThread().getName() + ": consume().synchronized <<");
        }
    }
}

ProducerConsumerExample.java

public class ProducerConsumerExample {
    public static void main(String[] args) {
        List<Integer> taskQueue = new ArrayList<Integer>();
        int MAX_CAPACITY = 5;
        Thread tProducer = new Thread(new Producer(taskQueue, MAX_CAPACITY), "Producer");
        Thread tConsumer = new Thread(new Consumer(taskQueue), "Consumer1");
        Thread tConsumer2 = new Thread(new Consumer(taskQueue), "Consumer2");
        tProducer.start();
        tConsumer.start();
        tConsumer2.start();
    }
}