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() {retu name;}@Overridepublic 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() {retu name;}@Overridepublic void run() {System.out.println("Hello I'm thread ".concat(getName()));// Do other things if required// Wait to be woken upwhile(true) {synchronized(this) {try {wait();break;} catch (InterruptedException e) {// ignore this}}}System.out.println("I'm finished ".concat(getName()));// Wake up the previous threadif (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;}@Overridepublic 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;}@Overridepublic 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();}}