加入一个线程
一个线程可以在其他线程调用join()方法,其效果是等待一段时间直到第二个线程结束才继续执行。也可以在调用join()时带上一个超时参数(单位可以是毫秒,秒或纳秒)
使用interrupt()方法可以中断join()方法
package com.javanet.thread;
/**
* 加入一个线程
*/
public class Joining {
public static void main(String[] args) {
Sleeper
sleepy= new Sleeper("Sleepy", 1500),
grumpy = new Sleeper("Grumpy", 1500);
Joiner
dopey = new Joiner("Dopey", sleepy),
doc = new Joiner("Doc", grumpy);
grumpy.interrupt();
}
}
class Sleeper extends Thread {
private int duration;
public Sleeper(String name, int sleepTime) {
super(name);
duration = sleepTime;
start();
}
@Override
public void run() {
try {
sleep(duration);
} catch (Exception e) {
System.out.println(getName() + " was interrupted." +
"isInterrupted(); " + isInterrupted());
return;
}
System.out.println(getName() + " has awakened");
}
}
class Joiner extends Thread {
private Sleeper sleeper;
public Joiner(String name, Sleeper sleeper) {
super(name);
this.sleeper = sleeper;
start();
}
@Override
public void run() {
try {
sleeper.join();
} catch (Exception e) {
System.out.println("Interrupted");
}
System.out.println(getName()+" join completed");
}
}
创建有响应的用户界面
package com.javanet.thread;
import java.io.IOException;
/**
* 创建有响应的用户界面
*/
public class Responsive {
public static void main(String[] args) throws IOException {
//! new UnresponsiveUI();
ResponsiveUI ru = new ResponsiveUI();
System.in.read();
System.out.println(ru.getD());
}
}
/**
* 这是一个无限循环程序,只能通过杀死进程方式关闭程序
*/
class UnresponsiveUI {
private volatile double d = 1;
public UnresponsiveUI() throws IOException {
while (d > 0) {
d = d + (Math.PI + Math.E) / d;
}
System.in.read();
}
}
class ResponsiveUI extends Thread {
private volatile double d = 1;
public double getD() {
return d;
}
public void setD(double d) {
this.d = d;
}
public ResponsiveUI() {
setDaemon(true);
start();
}
@Override
public void run() {
while (true) {
d = d + (Math.PI + Math.E) / d;
}
}
}
控制台输入1执行的结果
1
39230.935845773856
捕获异常
由于线程的本质特性,使得你不能捕获从线程中逃逸的异常。一旦异常逃出任务的run()方法,他就会向外传播到控制台,除非你采取特殊的步骤捕获这个错误的异常。在JAVA5之前你可以使用线程组来捕获这些异常,但有了java5,可以用Executor来解决这个问题。
package com.javanet.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 正常途径无法捕捉线程中的异常信息
*/
public class ExceptionThread implements Runnable {
@Override
public void run() {
throw new RuntimeException();
}
public static void main(String[] args) {
try {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new ExceptionThread());
} catch (Exception e) {
System.out.println("runtime failure");
}
}
}
执行结果
Exception in thread "pool-1-thread-1" java.lang.RuntimeException
at com.javanet.thread.ExceptionThread.run(ExceptionThread.java:17)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
at java.lang.Thread.run(Thread.java:745)
未解决上面的问题,我们要修改Executor产生线程的方式。Thread.UncaughtException-Handler是java5的新接口,它允许你在每个线程都附着一个异常处理器。Thread.UncaughtExceptionHandler.uncaughtExcetpion()会在线程因未捕获的异常临近死亡前被调用。为了使用它,我们创建了一个新类型的ThreadFactory,它将在每个新创建的Thread对象上附着一个Thread.UncaughtExcetpionHandler。我们将这个工厂传递给Executors创建新的ExecutorService的方法:
package com.javanet.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
public class CaptureUncaughtException {
public static void main(String[] args) {
ExecutorService exec = Executors.newCachedThreadPool(new HandlerThreadFactory());
exec.execute(new ExceptionThread2());
}
}
class ExceptionThread2 implements Runnable {
@Override
public void run() {
Thread t = Thread.currentThread();
// System.out.println("run() by " + t);
// System.out.println("eh = " + t.getUncaughtExceptionHandler());
throw new RuntimeException();
}
}
class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("caught " + e);
}
}
class HandlerThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
// System.out.println(this + " creating new Thread");
Thread t = new Thread(r);
// System.out.println("created " + t);
t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
// System.out.println("eh = " + t.getUncaughtExceptionHandler());
return t;
}
}
执行结果
caught java.lang.RuntimeException
更简单 的方式在Thread类中设置一个静态域,并将这个处理器设置为默认的未捕获的异常处理器
package com.javanet.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 设置默认的未捕获异常处理器
*/
public class SettingDefaultHandler {
public static void main(String[] args) {
Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new ExceptionThread());
}
}
执行结果
caught java.lang.RuntimeException
共享受限资源
互斥量:因为锁语句产生了一种相互排斥的效果,所以这种机制称为互斥量
块同步:synchronized
你该什么时候同步呢?
如果你正在写一个变量,它可能接下来将被另一个线程读取,或者正在读取一个上一次已经被另一个线程写过的变量,那么你必须使用同步,并且,读写线程都必须用相同的监视锁同步
package com.javanet.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 线程同步 Synchronized
*/
public class TestSynchronized {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new TestSyc(i));
}
}
}
class TestSyc implements Runnable {
private int id;
public TestSyc(int id) {
this.id = id;
}
@Override
public void run() {
synchronized (TestSyc.class) {
System.out.println("开始-"+id);
try {
TimeUnit.MILLISECONDS.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("结束-"+id);
}
}
}
执行结果:
开始-0
结束-0
开始-4
结束-4
开始-3
结束-3
开始-2
结束-2
开始-1
结束-1
显示的Lock对象
package com.javanet.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 描述
*/
public abstract class IntGenerator {
private volatile boolean canceled = false;
public abstract int next();
public void cancel() { canceled = true; }
public boolean isCanceled() { return canceled; }
}
class EventChecker implements Runnable {
private IntGenerator generator;
private final int id;
public EventChecker(IntGenerator g, int ident) {
generator = g;
id = ident;
}
@Override
public void run() {
while (!generator.isCanceled()) {
int val = generator.next();
if (val % 2 != 0) {
System.out.println(val + " not even!");
generator.cancel();
}
}
}
public static void test(IntGenerator gp, int count) {
System.out.println("Press Control-c to exit");
ExecutorService exec = Executors.newCachedThreadPool();
for (int i = 0; i < count; i++) {
exec.execute(new EventChecker(gp, i));
}
exec.shutdown();
}
public static void test(IntGenerator gp) {
test(gp, 10);
}
}
package com.javanet.thread;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Lock
*/
public class LockEventGenerator extends IntGenerator {
private int currentEventValue = 0;
private Lock lock = new ReentrantLock();
@Override
public int next() {
lock.lock();
try {
++currentEventValue;
Thread.yield();
++currentEventValue;
return currentEventValue;
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
EventChecker.test(new LockEventGenerator());
}
}
运行结果:
Press Control-c to exit
原子性和易用性
使用synchronized关键字是最安全的方式。
临界区
在其他对象上同步
线程本地储存
终结任务
在阻塞时终结
一个线程可以处于以下四种状态之一:
1、新建(new):当线程被创建时,它只会短暂的处于这种状态。此时它已经分配了必须的系统资源,并执行了初始化。此刻线程已经有资格获得CPU时间了,之后调度器将把这个线程转变为可运行状态或阻塞状态
2、就绪(Runnable):在这种状态下,只要调度器把时间片分配给线程,线程就可以运行。也就是说,在任意时刻,线程可以运行也可以不运行。只要调度器能分配时间片给线程,它可以运行;这不同于死亡和阻塞状态
3、阻塞(Blocked):线程能够运行,但有某个条件阻止它的运行。当线程处于阻塞状态时,调度器将忽略线程,不会分配给线程任何CPU时间。直到线程重新进入就绪状态,它才有可以能执行操作。
4、死亡(Dead):处于死亡或终止状态的线程将不再是可调度的,并且再也不会得到CPU时间,它的任务已结束,或不再是可运行的。任务死亡的通常方式是从run()方法返回。
进入阻塞状态
一个任务进入阻塞状态,可能有如下原因:
1、通过调用sleep(milliseconds)使任务进入休眠状态,在这种情况下,任务在指定的时间内不会运行
2、通过调用wait()使线程挂起。直到线程得到了notify()或notifyAll()消息(或在javase5的java.util.concurrent类库中等价的signal()或signalAll()消息),线程才会进入就绪状态。
3、任务在等待某个输入/输入完成
4、任务试图在某个对象上调用其同步控制方法,但是对象锁不可用,因为另一个任务已经获取了这个锁
中断
被互斥锁阻塞
检查中断
线程之间的协作
wait()与notifyAll()
wait(),设置当前线程等待直到另一个线程调用notify()或notifyAll()方法。有两种形式的wait,第一种接受毫秒数作为参数,含义与sleep方法里参数的意思相同,都是指“在此期间暂停”。但与sleep不同的是①wait期间对象锁是释放的②可以通过notify或notifyAll或令时间到期,从wait中恢复
notify(),唤醒一个等待的线程
notifyAll(),唤醒所有正在等待该锁的所有线程
都是基于Object类的,只能在同步控制方法或同步控制块里调用wait()、notify()或notifyAll()
下面是给汽车抛光打蜡的案例:
package com.javanet.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 先抛光,再打蜡
*/
public class WaxOMatic {
public static void main(String[] args) throws InterruptedException {
Car car = new Car();
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new WaxOff(car));
exec.execute(new WaxOn(car));
TimeUnit.SECONDS.sleep(5);
exec.shutdown();
}
}
class Car {
private boolean waxOn = false;
public synchronized void waxed() {
waxOn = true;
notifyAll();
}
public synchronized void buffed() {
waxOn = false;
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 car) {
this.car = car;
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
System.out.println("Waxing On!");
TimeUnit.MILLISECONDS.sleep(200);
car.waxed();
car.waitForBuffing();
}
} catch (InterruptedException e) {
System.out.println("Exiting via interrupt");
}
System.out.println("Ending Wax On task");
}
}
class WaxOff implements Runnable {
private Car car;
public WaxOff(Car car) {
this.car = car;
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
car.waitForWaxing();
System.out.println("Waxing Off!");
TimeUnit.MILLISECONDS.sleep(200);
car.buffed();
}
} catch (InterruptedException e) {
System.out.println("Exiting via interrupt");
}
System.out.println("Ending Wax Off task");
}
}
执行结果:
Waxing Off!
Waxing On!
Waxing Off!
Waxing On!
Waxing Off!
Waxing On!
Waxing Off!
Waxing On!
Waxing Off!
生产者与消费者
package com.javanet.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 生产者与消费者 一个饭店,它有一个厨师和一个服务员。这个服务员必须等待厨师准备好膳食,再上菜,然后继续等待。
* 这是一个任务协作的示例,厨师代表生产者,服务员代表消费者。两个任务必须在膳食生产和消费时进行握手 而系统必须以有序的方式关闭。
*/
public class Restaurant {
public Meal meal;
public ExecutorService exec = Executors.newCachedThreadPool();
public WaitPerson waitPerson = new WaitPerson(this);
public Chef chef = new Chef(this);
public Restaurant() {
exec.execute(chef);
exec.execute(waitPerson);
}
public static void main(String[] args) {
new Restaurant();
}
}
/**
* 服务员 消费者
*/
class WaitPerson implements Runnable {
private Restaurant restaurant;
public WaitPerson(Restaurant restaurant) {
this.restaurant = restaurant;
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
synchronized (this) {
while (restaurant.meal == null) {
wait();
}
}
System.out.println("waitperson got " + restaurant.meal);
synchronized (restaurant.chef) {
restaurant.meal = null;
restaurant.chef.notifyAll();
}
}
} catch (Exception e) {
System.out.println("waitPerson interrupted");
}
}
}
/**
* 厨师 生产者
*/
class Chef implements Runnable {
private Restaurant restaurant;
private int count = 0;
public Chef(Restaurant restaurant) {
this.restaurant = restaurant;
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
// 生产者等待
synchronized (this) {
while (restaurant.meal != null) {
wait();
}
}
if (++count == 10) {
System.out.println("out of food, closing!");
restaurant.exec.shutdownNow();
}
System.out.print("Order Up! ");
// 唤醒消费者
synchronized (restaurant.waitPerson) {
restaurant.meal = new Meal(count);
restaurant.waitPerson.notifyAll();
}
TimeUnit.MILLISECONDS.sleep(100);
}
} catch (InterruptedException e) {
System.out.println("chef interrupted");
}
}
}
class Meal {
private final int orderNum;
public Meal(int orderNum) {
this.orderNum = orderNum;
}
public String toString() {
return "Meal " + orderNum;
}
}
执行结果:
Order Up! waitperson got Meal 1
Order Up! waitperson got Meal 2
Order Up! waitperson got Meal 3
Order Up! waitperson got Meal 4
Order Up! waitperson got Meal 5
Order Up! waitperson got Meal 6
Order Up! waitperson got Meal 7
Order Up! waitperson got Meal 8
Order Up! waitperson got Meal 9
out of food, closing!
Order Up! waitPerson interrupted
chef interrupted
生产者与消费者和队列
package com.javanet.thread;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;
/**
* 生产者与消费者和队列
*/
public class TestBlockingQueues {
static void getKey() {
try {
new BufferedReader(new InputStreamReader(System.in)).readLine();
} catch (IOException e) {
e.printStackTrace();
}
}
static void getKey(String message) {
System.out.println(message);
getKey();
}
static void test(String msg, BlockingQueue<ListOff> queue) {
System.out.println(msg);
LiftOffRunner runner = new LiftOffRunner(queue);
Thread t = new Thread(runner);
t.start();
for (int i = 0; i < 5; i++) {
runner.add(new ListOff(5));
}
getKey("Press enter ("+msg+")");
t.interrupt();
System.out.println("Finished " + msg + " test");
}
public static void main(String[] args) {
test("LinkedBlockingQueue", new LinkedBlockingQueue<ListOff>());
test("ArrayBlockingQueue", new ArrayBlockingQueue<ListOff>(3));
test("SynchronousQueue", new SynchronousQueue<ListOff>());
}
}
class LiftOffRunner implements Runnable {
private BlockingQueue<ListOff> rockets;
public LiftOffRunner(BlockingQueue<ListOff> rockets) {
this.rockets = rockets;
}
public void add(ListOff lo) {
try {
rockets.put(lo);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
ListOff lo = rockets.take();
lo.run();//use this thread
}
} catch (Exception e) {
System.out.println("waking from takes");
}
System.out.println("Exiting ListOffRunner");
}
}
执行结果:
LinkedBlockingQueue
Press enter (LinkedBlockingQueue)
#0(4), #0(3), #0(2), #0(1), #0(ListOff!), #1(4), #1(3), #1(2), #1(1), #1(ListOff!), #2(4), #2(3), #2(2), #2(1), #2(ListOff!), #3(4), #3(3), #3(2), #3(1), #3(ListOff!), #4(4), #4(3), #4(2), #4(1), #4(ListOff!),
Finished LinkedBlockingQueue test
waking from takes
Exiting ListOffRunner
ArrayBlockingQueue
#5(4), #5(3), #5(2), #5(1), #5(ListOff!), Press enter (ArrayBlockingQueue)
#6(4), #6(3), #6(2), #6(1), #6(ListOff!), #7(4), #7(3), #7(2), #7(1), #7(ListOff!), #8(4), #8(3), #8(2), #8(1), #8(ListOff!), #9(4), #9(3), #9(2), #9(1), #9(ListOff!),
Finished ArrayBlockingQueue test
waking from takes
Exiting ListOffRunner
SynchronousQueue
#10(4), #10(3), #10(2), #10(1), #10(ListOff!), #11(4), #11(3), #11(2), #11(1), #11(ListOff!), #12(4), #12(3), #12(2), #12(1), #12(ListOff!), #13(4), #13(3), #13(2), #13(1), #13(ListOff!), #14(4), Press enter (SynchronousQueue)
#14(3), #14(2), #14(1), #14(ListOff!),
Finished SynchronousQueue test
waking from takes
Exiting ListOffRunner
吐司BlockingQueue
package com.javanet.thread;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
/**
* 吐司BlockingQueue
* 有一台机器具有三个任务:一个制作吐司、一个给吐司抹黄油、另一个在抹过黄油的吐司上涂果酱
* 我们可以通过各个处理之间的BlockingQueue来运行这个吐司制作程序
*/
public class ToastOmatic {
public static void main(String[] args) throws InterruptedException {
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.MILLISECONDS.sleep(5);
exec.shutdownNow();
}
}
/**
* 吐司
*/
class Toast {
public enum Status { DRY, BUTTERED, JAMMED }
private Status status = Status.DRY;
private final int id;
public Toast(int id) {
this.id = id;
}
public void butter() {
status = Status.BUTTERED;
}
public void jamm() {
status = Status.JAMMED;
}
public Status getStatus() {
return status;
}
public int getId() {
return id;
}
@Override
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 toastQueue) {
this.toastQueue = toastQueue;
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
TimeUnit.MILLISECONDS.sleep(100 + rand.nextInt(500));
//make toast
Toast t = new Toast(count++);
System.out.println(t);
//insert into queue
toastQueue.put(t);
}
} catch (Exception e) {
System.out.println("Toaster interrupted");
}
System.out.println("Toaster off");
}
}
/**
* 涂抹黄油
*/
class Butterer implements Runnable {
private ToastQueue dryQueue, butteredQueue;
public Butterer(ToastQueue dryQueue, ToastQueue butteredQueue) {
this.dryQueue = dryQueue;
this.butteredQueue = butteredQueue;
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
//blocks until next piece of toast is available
Toast t = dryQueue.take();
t.butter();
System.out.println(t);
butteredQueue.put(t);
}
} catch (Exception e) {
System.out.println("Butterer interrupted");
}
System.out.println("Butterer off");
}
}
/**
* 涂抹果酱
*/
class Jammer implements Runnable {
private ToastQueue butteredQueue, finishedQueue;
public Jammer(ToastQueue butteredQueue, ToastQueue finishedQueue) {
this.butteredQueue = butteredQueue;
this.finishedQueue = finishedQueue;
}
@Override
public void run() {
try {
while (!Thread.interrupted()) {
//blocks until next piece of toast is available
Toast t = butteredQueue.take();
t.jamm();
System.out.println(t);
finishedQueue.put(t);
}
} catch (Exception e) {
System.out.println("Jammer interrupted");
}
System.out.println("Jammer off");
}
}
/**
* 吃掉吐司
*/
class Eater implements Runnable {
private ToastQueue finishedQueue;
private int counter = 0;
public Eater(ToastQueue finishedQueue) {
this.finishedQueue = finishedQueue;
}
@Override
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) {
System.out.println(">>>> Error: " + t);
System.exit(1);;
} else {
System.out.println("Chomp!" + t);
}
}
} catch (Exception e) {
System.out.println("Eater interrupted");
}
System.out.println("Eater off");
}
}
任务间使用管道进行输入/输出
package com.javanet.thread;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 任务间使用管道进行输入/输出
*/
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.MILLISECONDS.sleep(4);
exec.shutdownNow();
}
}
class Sender implements Runnable {
private Random rand = new Random(47);
private PipedWriter out = new PipedWriter();
public PipedWriter getPipedWriter() {
return out;
}
@Override
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) {
System.out.println("Sender write exception");
} catch (InterruptedException e) {
System.out.println("Sender sleep exception");
}
}
}
class Receiver implements Runnable {
private PipedReader in;
public Receiver(Sender sender) throws IOException {
in = new PipedReader(sender.getPipedWriter());
}
@Override
public void run() {
try {
while (true) {
System.out.print("read: " + (char)in.read() + ", ");
}
} catch (Exception e) {
System.out.println("receiver read exception");
}
}
}
执行结果:
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, read: N, read: O, read: P, read: Q, read: R, read: S, read: T, read: U, read: V, read: W, read: X, read: Y, read: Z, Sender sleep exception
receiver read exception