—Input—>资源—Output—>
线程间通信:其实就是多个线程在操作同一个资源,但是操作的动作不同。
下面是一个关于线程间通信的例子:
/* 程序的部分运行结果:
Jack female
Lily male
Jack female
Jack female
毫无疑问,出现了多线程安全问题。
显然,我们可以通过同步的方式解决这个问题。
*/
class Resource {
String name;
String sex;
}
class Input implements Runnable {
private Resource r;
private int flag = 0;
Input(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true){
if (flag == 0) {
r.name = "Jack";
r.sex = "male";
}else {
r.name = "Lily";
r.sex ="female";
}
flag = (flag+1)%2;
}
}
}
class Output implements Runnable {
private Resource r;
Output(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true)
System.out.println(r.name + " " + r.sex);
}
}
public class Multithread {
/**
* @param args
*/
public static void main(String[] args) {
Resource r = new Resource();
Input in = new Input(r);
Output out = new Output(r);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}
下面是解决方法:
/*
部分运行结果:
Jack male
Jack male
Jack male
Jack male
Jack male
Lily female
Lily female
Lily female
Lily female
Lily female
Lily female
*/
class Input implements Runnable {
private Resource r;
private int flag = 0;
Input(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true){
synchronized(r) { // 这边的锁r,两个线程必须一样
if (flag == 0) {
r.name = "Jack";
r.sex = "male";
}else {
r.name = "Lily";
r.sex ="female";
}
flag = (flag+1)%2;
}
}
}
}
class Output implements Runnable {
private Resource r;
Output(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true) {
synchronized(r) { // 和Input中的锁是同一个
System.out.println(r.name + " " + r.sex);
}
}
}
}
通过上面的结果分析,可得通过同步解决了安全问题,但是还是无法实现输入一次,打印一次,再输入一次,再打印一次。要实现这种情况,那么我们就要用到等待唤醒机制,看代码:
/*
这种方法就是让两个线程交替的访问Resource对象。
*/
class Resource {
String name;
String sex;
boolean accessable = false; // 用来标识对象是否可以被操作
}
class Input implements Runnable {
private Resource r;
private int flag = 0;
Input(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true){
synchronized (r) {
if (r.accessable)
try {
r.wait(); // 我们是要wait持有r这个锁的线程,这个必须指明,因为同步可以嵌套同步
} catch (InterruptedException e) {
e.printStackTrace();
}
if (flag == 0) {
r.name = "Jack";
r.sex = "male";
}else {
r.name = "Lily";
r.sex ="female";
}
flag = (flag+1)%2;
r.accessable = true; // 为了唤醒Output对象
r.notify();
}
}
}
}
class Output implements Runnable {
private Resource r;
Output(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true)
synchronized (r){
if (!r.accessable)
try {
r.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(r.name + " " + r.sex);
r.accessable = false; // 为了唤醒Input对象
r.notify();
}
}
}
public class MuitThread {
/**
* @param args
*/
public static void main(String[] args) {
Resource r = new Resource();
Input in = new Input(r);
Output out = new Output(r);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}
wait(),notify(),notifyAll(),这三个方法都用在同步中,因为要对持有监视器(锁)的线程操作,而只有同步才具有锁。为什么这些操作线程的方法要定义在Object类中呢?因为这些方法在操作同步中的线程时,都必须标识它们所操作线程才有的锁(例如,r.wait(),r.notify(),这个r就是标识),等待和唤醒必须是同一把锁,而锁可以是任意对象,所以可以被任意对象调用的方法定义在Object中。
下面将代码优化一下,并利用同步函数实现:
class Resource {
private String name;
private String sex;
boolean accessable = false; // 用来标识对象是否可以被操作
public synchronized void set(String name, String sex){
if (accessable) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.name = name;
this.sex = sex;
accessable = true;
this.notify();
}
public synchronized void print() {
if (!accessable) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(name + " " + sex);
accessable = false;
this.notify();
}
}
class Input implements Runnable {
private Resource r;
private int flag = 0;
Input(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true){
if (flag == 0) {
r.set("Jack", "male");
}else {
r.set("Lily", "female");
}
flag = (flag+1)%2;
}
}
}
class Output implements Runnable {
private Resource r;
Output(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true)
r.print();
}
}
public class MuitThread {
public static void main(String[] args) {
Resource r = new Resource();
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
}
}
以上的例子都是一个生产者线程(Input)和一个消费者线程(Output),如果现在我们有多个生产者线程和多个消费者线程,那么会产生什么结果呢?让我们修改一下上面的代码:
如何停止线程?只有一种,run()方法结束。开启多线程运行,运行代码通常是循环结构。只要控制住循环,就可以让run()方法结束,也就是线程结束。特殊情况:当线程处于了冻结状态,就不会读取到标记,那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态时,这时需要对冻结进行清除。强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束。Thread类提供该方法 interrupt();它可以中断wait(),sleep(),join()方法。
守护线程(Thread类有一个方法是setDaemon(boolean flag),需要在启动前调用):即后台线程,当所有的前台线程都结束后,后台线程自动结束。
join()方法:等该线程结束,该线程未结束前,CPU的执行权一直在该线程中。join()方法可以用来临时加入线程执行。
Thread类的toString()方法:返回该线程的字符串表示形式,包括线程名称,优先级(默认优先级是5),线程组。
yield():暂停当前正在执行的线程,并执行其他线程。减缓线程的执行。