Java并发(4) 线程之间的协作
来源：互联网 发布：mac 减压rar文件 编辑：程序博客网 时间：2024/06/05 15:47
1. 线程之间的协作
可以通过使用同步锁来同步两个任务的行为, 防止资源被并发访问. 下面就是怎样使多个任务间可以协作, 使得多个任务可以一起去解决一个问题.
1.1 wait()和notify()
wait()可以使任务等待某个条件发生变化, 而改变这个条件超出了当前方法的控制能力, 通常这种条件将由另一个任务来改变. 只有在notify()和
notifyAll()发生时, 这个任务才会被唤醒并去检查锁发生的变化. 使用wait()将任务挂起时, 对象上的锁会被释放, 这就意味着其他任务可以获得锁,
其他的synchronized方法可以在其他的任务中调用. 也就为wait()要等待的条件发生变化提供了条件.
wait(), notify()和notifyAll()只能在同步控制块中进行调用.
下面的例子模拟了给汽车涂蜡和抛光
//: concurrency/waxomatic/WaxOMatic.java// Basic task cooperation.package concurrency.waxomatic;import java.util.concurrent.*;import static net.mindview.util.Print.*;class Car { private boolean waxOn = false; public synchronized void waxed() { waxOn = true; // Ready to buff notifyAll(); } public synchronized void buffed() { waxOn = false; // Ready for another coat of wax notifyAll(); } public synchronized void waitForWaxing() throws InterruptedException { while(waxOn == false) wait(); } public synchronized void waitForBuffing() throws InterruptedException { while(waxOn == true) wait(); }}class WaxOn implements Runnable { private Car car; public WaxOn(Car c) { car = c; } public void run() { try { while(!Thread.interrupted()) { printnb("Wax On! "); TimeUnit.MILLISECONDS.sleep(200); car.waxed(); car.waitForBuffing(); } } catch(InterruptedException e) { print("Exiting via interrupt"); } print("Ending Wax On task"); }}class WaxOff implements Runnable { private Car car; public WaxOff(Car c) { car = c; } public void run() { try { while(!Thread.interrupted()) { car.waitForWaxing(); printnb("Wax Off! "); TimeUnit.MILLISECONDS.sleep(200); car.buffed(); } } catch(InterruptedException e) { print("Exiting via interrupt"); } print("Ending Wax Off task"); }}public class WaxOMatic { public static void main(String[] args) throws Exception { Car car = new Car(); ExecutorService exec = Executors.newCachedThreadPool(); exec.execute(new WaxOff(car)); exec.execute(new WaxOn(car)); TimeUnit.SECONDS.sleep(5); // Run for a while... exec.shutdownNow(); // Interrupt all tasks }} /* Output: (95% match)Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Exiting via interruptEnding Wax On taskExiting via interruptEnding Wax Off task*///:~ 这个例子中对Car的控制权在WaxOn和WaxOff两个任务间来回切换, 打蜡后则挂起自己等待抛光, 抛光后则挂起自己等待打蜡. 对感兴趣的条件使用while循环包围wait()是有必要的:
1. 可能有多个任务处于相同的原因在等待同一个锁, 而第一个唤醒任务可能会改变这种状况, 那么这个任务需要被再次挂起.
2. 当任务从其wait()被唤醒的时刻, 可能会有某个其他任务已经做出了改变, 使得这个任务在此时不能执行, 或者没有必要执行, 应该再次被挂起.
3. 使用notifyAll()唤醒的时候, 可能还没有满足唤醒的条件, 需要重新挂起.
丢失的信号
一个丢失信号的例子
T1:
synchronized(sharedMonitor) {
<setup condition for T2>
sharedMonitor.notify();
}
T2:
while(someCondition) {
// point 1
synchronized(sharedMonitor) {
sharedMonitor.wait();
}
}
有可能在point1的时候, 被切换到了T1执行, 此时T2还没有被挂起, 但notify信号已经发出, 导致T2进入wait()后, 不能再接到notify信号, 而死锁.
解决办法是
synchronized(sharedMonitor) {
while(someCondition) {
sharedMonitor.wait();
}
}
2. notify()和notifyAll()
如果有多个任务在等待一个相同的条件, 那么更应该使用notifyAll(), 如果使用notify()就无法知道是否唤醒了恰当的任务. 但注意,notifyAll()并不是唤醒
任何处于wait的任务, 而只是等待某个特定锁的所有任务.
//: concurrency/NotifyVsNotifyAll.javaimport java.util.concurrent.*;import java.util.*;class Blocker { synchronized void waitingCall() { try { while(!Thread.interrupted()) { wait(); System.out.print(Thread.currentThread() + " "); } } catch(InterruptedException e) { // OK to exit this way } } synchronized void prod() { notify(); } synchronized void prodAll() { notifyAll(); }}class Task implements Runnable { static Blocker blocker = new Blocker(); public void run() { blocker.waitingCall(); }}class Task2 implements Runnable { // A separate Blocker object: static Blocker blocker = new Blocker(); public void run() { blocker.waitingCall(); }}public class NotifyVsNotifyAll { public static void main(String[] args) throws Exception { ExecutorService exec = Executors.newCachedThreadPool(); for(int i = 0; i < 5; i++) exec.execute(new Task()); exec.execute(new Task2()); Timer timer = new Timer(); timer.scheduleAtFixedRate(new TimerTask() { boolean prod = true; public void run() { if(prod) { System.out.print("\nnotify() "); Task.blocker.prod(); prod = false; } else { System.out.print("\nnotifyAll() "); Task.blocker.prodAll(); prod = true; } } }, 400, 400); // Run every .4 second TimeUnit.SECONDS.sleep(5); // Run for a while... timer.cancel(); System.out.println("\nTimer canceled"); TimeUnit.MILLISECONDS.sleep(500); System.out.print("Task2.blocker.prodAll() "); Task2.blocker.prodAll(); TimeUnit.MILLISECONDS.sleep(500); System.out.println("\nShutting down"); exec.shutdownNow(); // Interrupt all tasks }} /* Output: (Sample)notify() Thread[pool-1-thread-1,5,main]notifyAll() Thread[pool-1-thread-1,5,main] Thread[pool-1-thread-5,5,main] Thread[pool-1-thread-4,5,main] Thread[pool-1-thread-3,5,main] Thread[pool-1-thread-2,5,main]notify() Thread[pool-1-thread-1,5,main]notifyAll() Thread[pool-1-thread-1,5,main] Thread[pool-1-thread-2,5,main] Thread[pool-1-thread-3,5,main] Thread[pool-1-thread-4,5,main] Thread[pool-1-thread-5,5,main]notify() Thread[pool-1-thread-1,5,main]notifyAll() Thread[pool-1-thread-1,5,main] Thread[pool-1-thread-5,5,main] Thread[pool-1-thread-4,5,main] Thread[pool-1-thread-3,5,main] Thread[pool-1-thread-2,5,main]notify() Thread[pool-1-thread-1,5,main]notifyAll() Thread[pool-1-thread-1,5,main] Thread[pool-1-thread-2,5,main] Thread[pool-1-thread-3,5,main] Thread[pool-1-thread-4,5,main] Thread[pool-1-thread-5,5,main]notify() Thread[pool-1-thread-1,5,main]notifyAll() Thread[pool-1-thread-1,5,main] Thread[pool-1-thread-5,5,main] Thread[pool-1-thread-4,5,main] Thread[pool-1-thread-3,5,main] Thread[pool-1-thread-2,5,main]notify() Thread[pool-1-thread-1,5,main]notifyAll() Thread[pool-1-thread-1,5,main] Thread[pool-1-thread-2,5,main] Thread[pool-1-thread-3,5,main] Thread[pool-1-thread-4,5,main] Thread[pool-1-thread-5,5,main]Timer canceledTask2.blocker.prodAll() Thread[pool-1-thread-6,5,main]Shutting down*///:~1.3 生产者与消费者
下述代码模拟了饭店里厨师和服务员的情况, 厨师做菜, 做好后需要等服务器上菜后接着做, 服务器需要等厨师做好后才上菜.
//: concurrency/Restaurant.java// The producer-consumer approach to task cooperation.import java.util.concurrent.*;import static net.mindview.util.Print.*;class Meal { private final int orderNum; public Meal(int orderNum) { this.orderNum = orderNum; } public String toString() { return "Meal " + orderNum; }}class WaitPerson implements Runnable { private Restaurant restaurant; public WaitPerson(Restaurant r) { restaurant = r; } public void run() { try { while(!Thread.interrupted()) { synchronized(this) { while(restaurant.meal == null) wait(); // ... for the chef to produce a meal } print("Waitperson got " + restaurant.meal); synchronized(restaurant.chef) { restaurant.meal = null; restaurant.chef.notifyAll(); // Ready for another } } } catch(InterruptedException e) { print("WaitPerson interrupted"); } }}class Chef implements Runnable { private Restaurant restaurant; private int count = 0; public Chef(Restaurant r) { restaurant = r; } public void run() { try { while(!Thread.interrupted()) { synchronized(this) { while(restaurant.meal != null) wait(); // ... for the meal to be taken } if(++count == 10) { print("Out of food, closing"); restaurant.exec.shutdownNow(); } printnb("Order up! "); synchronized(restaurant.waitPerson) { restaurant.meal = new Meal(count); restaurant.waitPerson.notifyAll(); } TimeUnit.MILLISECONDS.sleep(100); } } catch(InterruptedException e) { print("Chef interrupted"); } }}public class Restaurant { Meal meal; ExecutorService exec = Executors.newCachedThreadPool(); WaitPerson waitPerson = new WaitPerson(this); Chef chef = new Chef(this); public Restaurant() { exec.execute(chef); exec.execute(waitPerson); } public static void main(String[] args) { new Restaurant(); }} /* Output:Order up! Waitperson got Meal 1Order up! Waitperson got Meal 2Order up! Waitperson got Meal 3Order up! Waitperson got Meal 4Order up! Waitperson got Meal 5Order up! Waitperson got Meal 6Order up! Waitperson got Meal 7Order up! Waitperson got Meal 8Order up! Waitperson got Meal 9Out of food, closingWaitPerson interruptedOrder up! Chef interrupted*///:~ 使用显示的Lock和Condition对象
使用它们重写WaxOMatic.java//: concurrency/waxomatic2/WaxOMatic2.java// Using Lock and Condition objects.package concurrency.waxomatic2;import java.util.concurrent.*;import java.util.concurrent.locks.*;import static net.mindview.util.Print.*;class Car { private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); private boolean waxOn = false; public void waxed() { lock.lock(); try { waxOn = true; // Ready to buff condition.signalAll(); } finally { lock.unlock(); } } public void buffed() { lock.lock(); try { waxOn = false; // Ready for another coat of wax condition.signalAll(); } finally { lock.unlock(); } } public void waitForWaxing() throws InterruptedException { lock.lock(); try { while(waxOn == false) condition.await(); } finally { lock.unlock(); } } public void waitForBuffing() throws InterruptedException{ lock.lock(); try { while(waxOn == true) condition.await(); } finally { lock.unlock(); } }}class WaxOn implements Runnable { private Car car; public WaxOn(Car c) { car = c; } public void run() { try { while(!Thread.interrupted()) { printnb("Wax On! "); TimeUnit.MILLISECONDS.sleep(200); car.waxed(); car.waitForBuffing(); } } catch(InterruptedException e) { print("Exiting via interrupt"); } print("Ending Wax On task"); }}class WaxOff implements Runnable { private Car car; public WaxOff(Car c) { car = c; } public void run() { try { while(!Thread.interrupted()) { car.waitForWaxing(); printnb("Wax Off! "); TimeUnit.MILLISECONDS.sleep(200); car.buffed(); } } catch(InterruptedException e) { print("Exiting via interrupt"); } print("Ending Wax Off task"); }}public class WaxOMatic2 { public static void main(String[] args) throws Exception { Car car = new Car(); ExecutorService exec = Executors.newCachedThreadPool(); exec.execute(new WaxOff(car)); exec.execute(new WaxOn(car)); TimeUnit.SECONDS.sleep(5); exec.shutdownNow(); }} /* Output: (90% match)Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Wax Off! Wax On! Exiting via interruptEnding Wax Off taskExiting via interruptEnding Wax On task*///:~ 这个例子比刚才的更加复杂, 只有在更加困难的多线程问题中才会用到.1.4 生产者与消费者队列
使用wait()和notify()是非常低级的方式解决任务互操作问题, 实际上, java.util.concurrent.BlockingQueue接口可以在更高层次上实现这个问题.
同步队列保证任何时刻只有一个任务插入或者移除元素. 通常可以使用LinkedBlockingQueue或ArrayBlockingQueue
下面的例子实现了不用显示的同步操作来实现LiftOffRunner
//: concurrency/TestBlockingQueues.java// {RunByHand}import java.util.concurrent.*;import java.io.*;import static net.mindview.util.Print.*;class LiftOffRunner implements Runnable { private BlockingQueue<LiftOff> rockets; public LiftOffRunner(BlockingQueue<LiftOff> queue) { rockets = queue; } public void add(LiftOff lo) { try { rockets.put(lo); } catch(InterruptedException e) { print("Interrupted during put()"); } } public void run() { try { while(!Thread.interrupted()) { LiftOff rocket = rockets.take(); rocket.run(); // Use this thread } } catch(InterruptedException e) { print("Waking from take()"); } print("Exiting LiftOffRunner"); }}public class TestBlockingQueues { static void getkey() { try { // Compensate for Windows/Linux difference in the // length of the result produced by the Enter key: new BufferedReader( new InputStreamReader(System.in)).readLine(); } catch(java.io.IOException e) { throw new RuntimeException(e); } } static void getkey(String message) { print(message); getkey(); } static void test(String msg, BlockingQueue<LiftOff> queue) { print(msg); LiftOffRunner runner = new LiftOffRunner(queue); Thread t = new Thread(runner); t.start(); for(int i = 0; i < 5; i++) runner.add(new LiftOff(5)); getkey("Press 'Enter' (" + msg + ")"); t.interrupt(); print("Finished " + msg + " test"); } public static void main(String[] args) { test("LinkedBlockingQueue", // Unlimited size new LinkedBlockingQueue<LiftOff>()); test("ArrayBlockingQueue", // Fixed size new ArrayBlockingQueue<LiftOff>(3)); test("SynchronousQueue", // Size of 1 new SynchronousQueue<LiftOff>()); }} ///:~ LiftOffRunner可以忽略同步问题, 因为它们已经被BlockingQueue解决了. 吐司BlockingQueue
//: concurrency/ToastOMatic.java// A toaster that uses queues.import java.util.concurrent.*;import java.util.*;import static net.mindview.util.Print.*;class Toast { public enum Status { DRY, BUTTERED, JAMMED } private Status status = Status.DRY; private final int id; public Toast(int idn) { id = idn; } public void butter() { status = Status.BUTTERED; } public void jam() { status = Status.JAMMED; } public Status getStatus() { return status; } public int getId() { return id; } public String toString() { return "Toast " + id + ": " + status; }}class ToastQueue extends LinkedBlockingQueue<Toast> {}class Toaster implements Runnable { private ToastQueue toastQueue; private int count = 0; private Random rand = new Random(47); public Toaster(ToastQueue tq) { toastQueue = tq; } public void run() { try { while(!Thread.interrupted()) { TimeUnit.MILLISECONDS.sleep( 100 + rand.nextInt(500)); // Make toast Toast t = new Toast(count++); print(t); // Insert into queue toastQueue.put(t); } } catch(InterruptedException e) { print("Toaster interrupted"); } print("Toaster off"); }}// Apply butter to toast:class Butterer implements Runnable { private ToastQueue dryQueue, butteredQueue; public Butterer(ToastQueue dry, ToastQueue buttered) { dryQueue = dry; butteredQueue = buttered; } public void run() { try { while(!Thread.interrupted()) { // Blocks until next piece of toast is available: Toast t = dryQueue.take(); t.butter(); print(t); butteredQueue.put(t); } } catch(InterruptedException e) { print("Butterer interrupted"); } print("Butterer off"); }}// Apply jam to buttered toast:class Jammer implements Runnable { private ToastQueue butteredQueue, finishedQueue; public Jammer(ToastQueue buttered, ToastQueue finished) { butteredQueue = buttered; finishedQueue = finished; } public void run() { try { while(!Thread.interrupted()) { // Blocks until next piece of toast is available: Toast t = butteredQueue.take(); t.jam(); print(t); finishedQueue.put(t); } } catch(InterruptedException e) { print("Jammer interrupted"); } print("Jammer off"); }}// Consume the toast:class Eater implements Runnable { private ToastQueue finishedQueue; private int counter = 0; public Eater(ToastQueue finished) { finishedQueue = finished; } public void run() { try { while(!Thread.interrupted()) { // Blocks until next piece of toast is available: Toast t = finishedQueue.take(); // Verify that the toast is coming in order, // and that all pieces are getting jammed: if(t.getId() != counter++ || t.getStatus() != Toast.Status.JAMMED) { print(">>>> Error: " + t); System.exit(1); } else print("Chomp! " + t); } } catch(InterruptedException e) { print("Eater interrupted"); } print("Eater off"); }}public class ToastOMatic { public static void main(String[] args) throws Exception { ToastQueue dryQueue = new ToastQueue(), butteredQueue = new ToastQueue(), finishedQueue = new ToastQueue(); ExecutorService exec = Executors.newCachedThreadPool(); exec.execute(new Toaster(dryQueue)); exec.execute(new Butterer(dryQueue, butteredQueue)); exec.execute(new Jammer(butteredQueue, finishedQueue)); exec.execute(new Eater(finishedQueue)); TimeUnit.SECONDS.sleep(5); exec.shutdownNow(); }} /* (Execute to see output) *///:~ 1.5 任务间使用管道进行输入/输出
//: concurrency/PipedIO.java// Using pipes for inter-task I/Oimport java.util.concurrent.*;import java.io.*;import java.util.*;import static net.mindview.util.Print.*;class Sender implements Runnable { private Random rand = new Random(47); private PipedWriter out = new PipedWriter(); public PipedWriter getPipedWriter() { return out; } public void run() { try { while(true) for(char c = 'A'; c <= 'z'; c++) { out.write(c); TimeUnit.MILLISECONDS.sleep(rand.nextInt(500)); } } catch(IOException e) { print(e + " Sender write exception"); } catch(InterruptedException e) { print(e + " Sender sleep interrupted"); } }}class Receiver implements Runnable { private PipedReader in; public Receiver(Sender sender) throws IOException { in = new PipedReader(sender.getPipedWriter()); } public void run() { try { while(true) { // Blocks until characters are there: printnb("Read: " + (char)in.read() + ", "); } } catch(IOException e) { print(e + " Receiver read exception"); } }}public class PipedIO { public static void main(String[] args) throws Exception { Sender sender = new Sender(); Receiver receiver = new Receiver(sender); ExecutorService exec = Executors.newCachedThreadPool(); exec.execute(sender); exec.execute(receiver); TimeUnit.SECONDS.sleep(4); exec.shutdownNow(); }} /* Output: (65% match)Read: A, Read: B, Read: C, Read: D, Read: E, Read: F, Read: G, Read: H, Read: I, Read: J, Read: K, Read: L, Read: M, java.lang.InterruptedException: sleep interrupted Sender sleep interruptedjava.io.InterruptedIOException Receiver read exception*///:~ 线程间通信可以使用输入/输出实现, Java实现了PipedWritter和PipedReader. PipedReader与普通IO最重要的差异就是它们是可中断的.
synchronized(sharedMonitor) {
0 0
- Java并发(4) 线程之间的协作
- Java并发-线程之间的协作
- Java并发（4）：线程的协作
- Java并发之线程之间协作
- java并发 --线程的协作
- JAVA线程---线程之间的协作
- Java并发之线程间的协作
- 线程之间的协作
- 线程之间的协作
- 线程之间的协作
- 漫谈并发编程(五)：线程之间的协作
- Java线程：并发协作-死锁
- Java线程：并发协作-死锁
- Java线程：并发协作-死锁
- Java线程：并发协作-死锁
- Java线程：并发协作-死锁
- Java线程：并发协作-死锁
- Java线程：并发协作-死锁
- java.lang.IllegalStateException: BeanFactory not initialized or already closed - call 'refresh' befo
- Codeforces 474D - Flowers（0 - 1背包）
- 第一次开博
- OpenGL学习网站及资料
- 【Java】【TIJ】构建一个类：这个类只有一个对象（实例）
- Java并发(4) 线程之间的协作
- Hadoop学习记录-Hive
- Java调用动态库方法
- Facebook KeyHash生成方法
- mysql存储过程详解
- 基于内容的推荐算法
- Leetcode Best Time to Buy and Sell Stock III
- 闭包
- Python之一些小知识点
