线程同步通信及其应用等相关内容及代码

线程间的通信：
两个或两个以上的线程处理同一个资源，处理的动作是不一样的。
这样就需要将不同的动作代码放到不同的run方法中，run方法要封装到单独的类中。

同步中使用：
wait()：让当前线程处于等待状态，释放cpu资源，同时释放锁。
notify()：唤醒等待的线程，唤醒第一个
notifyAll()：唤醒所以等待的线程。

object类的方法

wait()：让当前线程处于等待状态，释放cpu资源，同时释放锁。
sleep():释放cpu资源,但是不释放锁。

多线程在开发中的应用
1.下载
2.聊天

实例，生产者和消费者。

分析：
生产者-消费者问题是多线程同步处理的典型问题
有一块生产者和消费者共享

的有界缓冲区，生产者往缓冲区放入产品，消费者从缓冲区取走产品，这个过程可以无

休止的执行，不能因缓冲区满生产者放不进产品而终止，也不能因缓冲区空消费者无产

品可取而终止。

线程B写一次，线程A读一次
在某个时候线程B运行速度比较快，在线程A未读取上一个数据之前，B就写了第二次数据

，造成数据遗漏。
在某个时候线程A运行速度比较快，它读完一次数据之后，线程B还没来得及写，线程A又

来读第二次。结果线程A读不到数据，导致运行出错。
线程B正在写数据时，线程A也来读取数据，这时可能线程B还没将数据写完，线程A将数

据读走，导致程序出错。

解决生产者消费者问题的方法

一种是采用某种机制保持生产者和消费者之间的同步(有较高的效率并且可控制性较好，

比较常用
)
一种是在生产者和消费者之间建立一个管道(由于管道缓冲区不易控制及被传输数据对象

不易封装等原因，比较少用
)
程的同步解决生产者-消费者问题

限制公共缓冲区不能被两个线程同时访问，需要使用互斥锁，即用synchronized来标识

同步资源。

但加了互斥锁以后有可能会造出死锁。这时需要wait()方法和notify()方法--当前线程

被阻塞并释放该对象的互斥锁。

生产者与消费者实例应用代码（修改前，不够简洁）：

package com.hbsi;

//资源类
class Res {
String name;
String sex;
boolean b;
}

// 生产者类
class Input implements Runnable {
private Res r;

public Input(Res r) {
this.r = r;
}

int x = 0;

public void run() {
while (true) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (r) {
//判断是否需要生产
if(r.b)
try {
r.wait();//释放CPU资源同时释放锁
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (x == 0) {
r.name = "张三";
r.sex = "男";
} else {
r.name = "lisi";
r.sex = "nv";
}
r.b=true;
r.notify();
x = (x + 1) % 2;
}
}
}
}

// 消费者类
class Output implements Runnable {
private Res r;

public Output(Res r) {
this.r = r;
}

public void run() {
while (true) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (r) {
if(!r.b)
try {
r.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(r.name + "..." + r.sex);
r.b=false;
r.notify();
}
}
}
}

public class ThreadDemo4 {
public static void main(String[] args) {
Res t = new Res();
Input in = new Input(t);
Output out = new Output(t);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}

生产者与消费者实例应用代码（修改后，更符合编程的要求）：

package com.hbsi;

//对ThreadDemo4进行优化
class Res1 {
private String name;
private String sex;
private boolean flag;

public synchronized void set(String name, String sex) {
if (flag)
try {
wait();//相当于this.wait();锁
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.name = name;
this.sex = sex;
flag = true;
notify();
}

public synchronized void out() {
if (!flag)
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(name + "...." + sex);
flag = false;
notify();
}
}

// 生产者类
class Input1 implements Runnable {
private Res1 r;

public Input1(Res1 r) {
this.r = r;
}

int x = 0;

public void run() {
while (true) {
if (x == 0) {
r.set("张三", "男");
} else {
r.set("lisi", "nv");
}
x = (x + 1) % 2;
}
}
}

// 消费者类
class Output1 implements Runnable {
private Res1 r;

public Output1(Res1 r) {
this.r = r;
}

public void run() {
while (true) {
r.out();
}
}
}

public class ThreadDemo5 {
public static void main(String[] args) {
Res1 t = new Res1();
Input1 in = new Input1(t);
Output1 out = new Output1(t);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}