目录:

  1. 线程间的通信示例
  2. 等待唤醒机制
  3. 等待唤醒机制的优化
  4. 线程间通信经典问题:多生产者多消费者问题
  5. 多生产多消费问题的解决
  6. JDK1.5之后的新加锁方式
  7. 多生产多消费问题的新解决办法
  8. sleep和wait的区别
  9. 停止线程的方式
  10. 守护线程
  11. 线程的其他知识点

一、线程间的通信示例 目录

多个线程在处理同一资源,任务却不同。

假设有一堆货物,有一辆车把这批货物往仓库里面运,另外一辆车把前一辆车运进仓库的货物往外面运。这里货物就是同一资源,但是两辆车的任务却不同,一个是往里运,一个是往外运。

下面举例子来逐步展示线程间通信:首先建立一个Person类。包含 name 和 sex 属性, 我们建立一个线程输入一个对象(即输入一个name和sex), 另一个线程输出该对象(即输出该对象的name 和 sex).

 package thread.demo;

 class Person
{
private String name;
private String sex; public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getSex()
{
return sex;
}
public void setSex(String sex)
{
this.sex = sex;
} }
//输入
class Input implements Runnable
{
private Person r; Input(Person r)
{
this.r = r;
} public void run()
{
int x = 0;
while(true)//这里加无限循环是为了方便后面观察现象
{
if (x == 0)
{
r.setName("Mike");
r.setSex("Male");
}
else
{
r.setName("Lucy");
r.setSex("Female");
}
x = (x + 1) % 2; //变换x的值,使得切换输入不同的对象
}
}
} class Output implements Runnable
{
private Person r; Output(Person r)
{
this.r = r;
} public void run()
{
while(true)//这里加无限循环是为了方便后面观察现象
{
System.out.println(r.getName() + "..." + r.getSex());
}
}
}
public class MultithreadDemo_1
{ /**
* @param args
*/
public static void main(String[] args)
{
//建立共享数据Person r,输入和输出都操作对象 r
Person r = new Person();
Input in = new Input(r);
Output out = new Output(r); //建立两个线程,分别执行输入任务和输出任务
Thread t1 = new Thread(in);
Thread t2 = new Thread(out); //开启线程
t1.start();
t2.start();
}
}

执行结果就是一直不断输出,会发现有如下类似现象:

问题来了,程序中明明Mike的sex是Male,Lucy是Female,却出现了上面图片中“诡异”的的现象,这当然是线程安全问题!来分析一下:

在上一篇博文Java多线程技术学习笔记(一)中分析了线程安全问题产生的原因:

  • 多个线程操作共享的数据
  • 操作共享数据的线程代码有多条

回头看我们的代码,共享数据Person r被两个线程操作,满足第一条;操作 r 的代码就是run方法里面的代码,看到第36行开始的run方法确实有很多条,满足第二个条件!所以出现上述诡异输出其实是很正常的现象!具体到上述代码,造成原因:

  • 假设线程0即Input线程,首先抢到cpu执行权,由于x==0, 那么Person对象r的name就是Mike, sex就是Male, 然后x = (x + 1)%2 = 1.
  • 接着有可能Input线程继续占有着cpu执行权, 由于39行的while(true)和x == 1,执行到48行,这时 r 的name = Lucy,问题来了,Input线程还没有来得及更新r的sex,即还没有来得及执行第49行代码,这时线程1,Output线程把cpu执行抢走了。
  • 于是此时r的name就是Lucy,而sex由于没来得及改变还是Male,然后Output线程输出:Lucy...Male! 产生Mike...Female的过程与此类似!

分析了原因,就来解决问题,那就是前一篇博文笔记里面说的同步:

 //输入
class Input implements Runnable
{
private Person r; Input(Person r)
{
this.r = r;
} public void run()
{
int x = 0;
while(true)//这里加无限循环是为了方便后面观察现象
{
synchronized(r)//同步代码块的锁可以使用任意对象,只要保证多个线程使用的是同一个锁即可
{
if (x == 0)
{
r.setName("Mike");
r.setSex("Male");
}
else
{
r.setName("Lucy");
r.setSex("Female");
}
}
x = (x + 1) % 2; //变换x的值,使得切换输入不同的对象
}
}
} class Output implements Runnable
{
private Person r; Output(Person r)
{
this.r = r;
} public void run()
{
while(true)//这里加无限循环是为了方便后面观察现象
{
synchronized(r)
{
System.out.println(r.getName() + "..." + r.getSex());
}
}
}
}

多次运行之后可以验证,输出正常:

但是注意到,输出是连续一堆Lucy...Female,然后连续一堆Mike...Male,原因很简单:一旦切换到输出线程,该线程不可能只执行一次,一下输出多次,因为name 和 sex 由于同步的缘故,要么是Lucy...Female,要么是Mike...Male,一输出就是一片相同的Lucy或者Mike. 为了展示多线程间的通信,现在要实现的是,输入线程输入一个name和sex,就立马在输出线程输出,然后再输入一个,再输出一个,如此交替!注意输入和输出是在不同线程里面执行的!所以就需要线程间通信,即输入线程输了一个name和sex,就不在继续输入,而是去通知输出线程输出一下刚才输入的name和sex,输出一次之后,也不再继续输出,而是去通知输入线程继续输入新的内容,输入线程和输出线程如此交替... 这就是所谓的“等待唤醒机制”。

二、等待唤醒机制 目录

要达到上面所说的输入和输出线程交替执行,需要设置一个标志位,根据标志位来判断到底是该执行输出还是输出!

涉及的方法:

  • wait():让线程处于冻结状态,被wait的线程会被存储到线程池,所有等待的线程都在这个池子里面,等待机会去执行。该方法是从java.lang.Object继承过来的:

  翻译过来意思就是:该方法会导致当前线程等待,直到其他线程调用了此线程的notify或者notifyAll方法。 注意到wait方法会抛出异常,所以在面我们的代码中加入了try/catch

  • nofity():唤醒线程池中任意一个线程。
  • notifyAll():唤醒线程池中的所有线程。

这些方法都必须定义在同步中。因为这些方法是用于操作线程状态的方法,所以必须要明确到底操作的是哪个锁上的线程。

注意到上述操作线程的方法都是放在Object类中,这是因为方法都是同步锁的方法。而锁可以是任意对象,任意的对象都可以调用的方法一定定义在Object类中。

代码思路:初始化标志位-->输入线程输入-->更改标志位-->唤醒输出线程-->输出线程输出-->更该标志位-->唤醒输入线程-->输入线程输入--> ...

代码改动如下:

 package thread.demo;
/*
* 等待/唤醒机制
*/
class Person
{
private String name;
private String sex;
boolean full = false;//标志位,代表着是否已经更新了name和sex public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getSex()
{
return sex;
}
public void setSex(String sex)
{
this.sex = sex;
} }
//输入
class Input implements Runnable
{
private Person r; Input(Person r)
{
this.r = r;
} public void run()
{
int x = 0;
while(true)//这里加无限循环是为了方便后面观察现象
{
synchronized(r)//同步代码块的锁可以使用任意对象,只要保证多个线程使用的是同一个锁即可
{
if (r.full)
{
// 如果full标志位为真
// r锁的wait方法让线程冻结,在线程池中等待,就不执行后面的输入name和sex的语句
try {
r.wait();//注意调用wait方法要明确锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果标志位为假,就执行下面语句输入name和sex
if (x == 0)
{
r.setName("Mike");
r.setSex("Male");
}
else
{
r.setName("Lucy");
r.setSex("Female");
}
//输入了一个对象,即一对name和sex之后,将标志位置为真
r.full = true;
//然后通知输出线程(即唤醒输出线程)来输出刚输入的内容
r.notify();
}
x = (x + 1) % 2; //变换x的值,使得切换输入不同的对象
}
}
} class Output implements Runnable
{
private Person r; Output(Person r)
{
this.r = r;
} public void run()
{
while(true)//这里加无限循环是为了方便后面观察现象
{
synchronized(r)
{
//如果输入线程还没有输入内容,输出线程就等待
if (!r.full)
{
try {
r.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果已经输入了内容,就直接输出
System.out.println(r.getName() + "..." + r.getSex());
//输出完了之后,将标志位置为false,表明刚才的内容应经输出了
r.full = false;
//然后通知输入线程再输入新内容
r.notify();
}
}
}
}
public class MultithreadDemo_1
{ /**
* @param args
*/
public static void main(String[] args)
{
//建立共享数据Person r,输入和输出都操作对象 r
Person r = new Person();
Input in = new Input(r);
Output out = new Output(r); //建立两个线程,分别执行输入任务和输出任务
Thread t1 = new Thread(in);
Thread t2 = new Thread(out); //开启线程
t1.start();
t2.start();
}
}

运行结果:

达到了预期。

三、等待唤醒机制的优化 目录

再考虑上面写的代码,其实并不好,同步的目的是为了防止某个线程对name赋值以后,还没来得及对sex赋值时,其他线程就切了进来!所以需要同步的代码就是赋值的两行:

59,60行代码与64,65行代码代码功能重复,所以优化代码如下:

 package thread.demo;
/*
* 等待/唤醒机制
*/
class Person
{
private String name;
private String sex;
private boolean full = false;//标志位,代表着是否已经更新了name和sex public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getSex()
{
return sex;
}
public void setSex(String sex)
{
this.sex = sex;
} public synchronized void set(String name, String sex)
{
if (full)
{
try
{
this.wait(); //注意同步函数的锁是this,所以这里调用this的wait方法
}
catch (InterruptedException e)
{
e.printStackTrace();
}
} this.name = name;
this.sex = sex;
full = true;
notify();
} public synchronized void show()
{
if (!full)
{
try
{
this.wait(); //注意同步函数的锁是this,所以这里调用this的wait方法
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
//如果已经输入了内容,就直接输出
System.out.println(name + "..." + sex);
full = false;
notify();
}
}
//输入
class Input implements Runnable
{
private Person r; Input(Person r)
{
this.r = r;
} public void run()
{
int x = 0;
while(true)//这里加无限循环是为了方便后面观察现象
{
if (x == 0)
{
r.set("Mike", "Male");
}
else
{
r.set("Lucy", "Female");
}
x = (x + 1) % 2; //变换x的值,使得切换输入不同的对象
}
}
} class Output implements Runnable
{
private Person r; Output(Person r)
{
this.r = r;
} public void run()
{
while(true)//这里加无限循环是为了方便后面观察现象
{
r.show();
}
}
}
public class MultithreadDemo_1
{ /**
* @param args
*/
public static void main(String[] args)
{
//建立共享数据Person r,输入和输出都操作对象 r
Person r = new Person();
Input in = new Input(r);
Output out = new Output(r); //建立两个线程,分别执行输入任务和输出任务
Thread t1 = new Thread(in);
Thread t2 = new Thread(out); //开启线程
t1.start();
t2.start();
}
}

功能与前面代码其实是一样的。

四、线程间通信经典问题:多生产者多消费者问题 目录

这个问题很直接:就是一堆生产者生产产品,同时一堆消费者在消费产品!这一堆生产者和消费者对应程序中的多个线程,而产品就对应着这一堆线程共同操作的资源或者叫做共享数据。

我们想达到的目的是生产一件商品,消费一件,生产消费彼此交替!

首先来看一个生产者,一个消费者的例子,即生产一个就消费一个:

 package thread.demo;

 /*
* 生产者消费者问题
*/
class Product
{
private String name;// 产品名称
private int number = 1; // 产品编号
private boolean notEmpty = false;
public synchronized void produce(String name)
{
//如果有产品,可以停止生产一会
if (notEmpty)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
// 如果没有产品,就无需等待,直接生产
// 生产的产品名称
this.name = name + number;
// 编号递增
number++;
// 输出生产的产品信息:线程名(对应在某一个生产者)+产品名
System.out.println(Thread.currentThread().getName() + " 生产出: " + this.name);
// 生产完了以后,就有了产品
notEmpty = true;
//通知消费者来消费
notify();
} public synchronized void consume()
{
// 如果没有产品,无法消费,等待
if (!notEmpty)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
//打印产品被消费的信息:线程名(对应着某一个消费者) + 产品名
System.out.println(Thread.currentThread().getName() + "消费了:-> " + this.name);
//消费完了,通知生产者
notEmpty = false;
notify();
}
} // 创建生产者线程
class Producer implements Runnable
{
private Product p;
Producer(Product p)
{
this.p = p;
} public void run()
{
while (true)
{
p.produce("bread"); // 假如生产面包
}
} } //创建消费者线程
class Consumer implements Runnable
{
private Product p;
Consumer(Product p)
{
this.p = p;
} public void run()
{
while (true)//消费者消费
{
p.consume();
}
} }
public class ProducerConsumerDemo { public static void main(String[] args)
{
// 创建共享资源
Product p = new Product();
// 创建两个线程:生产和消费
Producer producer = new Producer(p);
Consumer consumer = new Consumer(p);
Thread t1 = new Thread(producer);
Thread t2 = new Thread(consumer);
t1.start();
t2.start();
}
}

运行结果:

这其实就是前面等待唤醒机制的另一种展示!下面在此代码的基础上改成多生产者,多消费者的示例:

 public class ProducerConsumerDemo {

     public static void main(String[] args)
{
// 创建共享资源
Product p = new Product();
// 两个生产者,两个消费者
Producer producer = new Producer(p);
Consumer consumer = new Consumer(p);
Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer); Thread t2 = new Thread(consumer);
Thread t3 = new Thread(consumer); t0.start();
t1.start();
t2.start();
t3.start();
}
}

多次运行,会出现下面类似结果:

产生的问题:

  • bread15865:一个面包被生产两次
  • bread15866:一个面包被吃了两次
  • bread15867:这个面包还没消费掉就去生产下一个面包
  • 还有时生产一大片,却没能消费(多次运行会观察到)

显然这些问题都是不合理的,问题肯定出在多线程上,下面分分析。为了方便叙述,代码全部整理如下:

 package thread.demo;

 /*
* 生产者消费者问题
*/
class Product
{
private String name;// 产品名称
private int number = 1; // 产品编号
private boolean notEmpty = false;
public synchronized void produce(String name)
{
//如果有产品,可以停止生产一会
if (notEmpty)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
// 如果没有产品,就无需等待,直接生产
// 生产的产品名称
this.name = name + number;
// 编号递增
number++;
// 输出生产的产品信息:线程名(对应在某一个生产者)+产品名
System.out.println(Thread.currentThread().getName() + " 生产出: " + this.name);
// 生产完了以后,就有了产品
notEmpty = true;
//通知消费者来消费
notify();
} public synchronized void consume()
{
// 如果没有产品,无法消费,等待
if (!notEmpty)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
//打印产品被消费的信息:线程名(对应着某一个消费者) + 产品名
System.out.println(Thread.currentThread().getName() + "消费了:-> " + this.name);
//消费完了,通知生产者
notEmpty = false;
notify();
}
} // 创建生产者线程
class Producer implements Runnable
{
private Product p;
Producer(Product p)
{
this.p = p;
} public void run()
{
while (true)
{
p.produce("bread"); // 假如生产面包
}
} } //创建消费者线程
class Consumer implements Runnable
{
private Product p;
Consumer(Product p)
{
this.p = p;
} public void run()
{
while (true)//消费者消费
{
p.consume();
}
} }
public class ProducerConsumerDemo { public static void main(String[] args)
{
// 创建共享资源
Product p = new Product();
// 两个生产者,两个消费者
Producer producer = new Producer(p);
Consumer consumer = new Consumer(p);
Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer); Thread t2 = new Thread(consumer);
Thread t3 = new Thread(consumer); t0.start();
t1.start();
t2.start();
t3.start();
}
}
  • 假设生产者(t0或者t1线程)得到cpu执行权,开始notEmpty为false,那么就需要去生产,执行到第27行,表示生产出了一个面包。然后number加1变为2 --> 打印信息-->notEmpty变为true-->notify()-->释放线程锁this;
  • 因为nofity是唤醒与锁相关的线程池中的任意线程,所以生产者有可能再次抢到cpu执行权,再次进入第11行的同步函数,但是进入之后发现notEmpty为true,就进入了等待状态。同样如果生产者再次抢到cpu执行权,还是会等待。
  • 继续,如果消费者(t2或者t3线程)抢到执行权,进入第38行的同步函数,判断(!notEmpty)为false,就去53行打印消费信息,代表消费了面包,然后notEmpty变为false,调用notify,释放线程锁,如上面生产者情况类似。倘若消费者再次抢到cpu执行权,就会因为判断标志位而变为等待。
  • 继续,生产者抢到cpu执行权,循环上面的步骤...

按照上面分析,是不会出现上述运行现象的,于是进一步分析:

  • 假设生产线程t0生产了第一个面包,标志位转换,t0接着又抢到执行权,根据14行标记判断,就转为等待,假设接着生产线程t1又抢到cpu执行权,同样在14行判断标记,t1又转为等待;
  • 然后消费者线程t2此时切入,消费了一次,标志位转换,然后notify去唤醒任意线程,假设此时等待的t0被唤醒,即具有执行资格,但是不一定抢到执行权;
  • 如果t3接着抢到执行权,根据第41行标志位判断,转为等待;
  • 注意此时t1, t2, t3都在等待,被唤醒状态的只有t0;
  • 于是t0很容易得到执行权,从第18行开始继续往下执行,由于没有异常发生,就不会执行catch语句,然后接着27行开始往下执行,生产了第二个面包,标志位转换true,然后notify(),问题来了,由于notify唤醒线程池中的处于等待的t1,t2,t3中的任意一个线程,如果此时唤醒了t2或者t3(消费线程),那就是正常的.
  • 但是如果唤醒了t1, 倘若t0此时继续占有cpu执行权,继续执行,判断标志,t0转为等待, t1同样从18行开始往下执行, 于是第二个面包还没被消费,t1又生产了第三个面包!!
  • 上面的过程就是t0唤醒t1,然后t1唤醒t0,即两个生产者之间可以互相唤醒,有可能一直生产不消费,也有可能生产线程执行了几次才去唤醒消费线程一次,即生产了多次才消费一次!
  • 同样的道理,两个消费者线程t2和t3也可以互相唤醒,就会导致对同一面包直消费,或者消费多次之后才去生产一次。

把程序中的四个线程画图分析如下:

其中双向箭头表示所连接的两线程可以互相唤醒。假如存在A箭头或者B箭头连续执行的情况,就会出现连续生产多个产品而不消费的情况,或者连续消费同一个产品而不生产的情况。很显然只要发生中间四个箭头的情况,就会生产一个,消费一个,从而满足我们的目的。所以解决的原因显而易见:防止A和B情况的发生,即生产者线程不能唤醒生产者线程,只能唤醒消费者线程,而消费者线程也只允许唤醒生产者线程。

五、多生产多消费问题的解决 目录

上面分析到,t0唤醒t1后,由于t1从wait处醒过来不判断标记就继续往下执行,就出现了多生产,试想如果t1在被唤醒之后判断一下标记,t1会再次等待,即使t0再次过来也再次判断标记,也会一直等待,而不会去连续多次生产了,所以把14行和41行的 if 改为while,这样,每一个线程被唤醒之后就必须重新判断标记,改动之后运行结果如下:

现象就是运行若干次程序停止了,即就是在Java多线程技术学习笔记(一)提到的死锁现象,分析原因如下:

  • 生产一次后,t0, t1等待,然后通知消费者
  • 消费一次,t2,t3等待,notEmpty就变为true,
  • 假如唤醒了t0,有可能出现:t0判断标记true, t0等待,唤醒线程t1,t1判断标记true,也等待
  • 由于t1等待,无法执行到下面的notify方法,线程都无法被唤醒,所以四个线程都等待,程序就一直等

虽然线程每次都重新判断了标记,但是会出现上面死锁的现象,考虑到上面说到notifyAll方法还没有出场过,试着把notify改为notifyAll:

 package thread.demo;

 /*
* 生产者消费者问题
*/
class Product
{
private String name;// 产品名称
private int number = 1; // 产品编号
private boolean notEmpty = false;
public synchronized void produce(String name)
{
//如果有产品,可以停止生产一会
while (notEmpty)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
// 如果没有产品,就无需等待,直接生产
// 生产的产品名称
this.name = name + number;
// 编号递增
number++;
// 输出生产的产品信息:线程名(对应在某一个生产者)+产品名
System.out.println(Thread.currentThread().getName() + " 生产出: " + this.name);
// 生产完了以后,就有了产品
notEmpty = true;
//通知其他线程
//notify();
notifyAll(); } public synchronized void consume()
{
// 如果没有产品,无法消费,等待
while (!notEmpty)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
//打印产品被消费的信息:线程名(对应着某一个消费者) + 产品名
System.out.println(Thread.currentThread().getName() + "消费了:-> " + this.name);
//消费完了,通知其他线程
notEmpty = false;
//notify();
notifyAll();
}
} // 创建生产者线程
class Producer implements Runnable
{
private Product p;
Producer(Product p)
{
this.p = p;
} public void run()
{
while (true)
{
p.produce("bread"); // 假如生产面包
}
} } //创建消费者线程
class Consumer implements Runnable
{
private Product p;
Consumer(Product p)
{
this.p = p;
} public void run()
{
while (true)//消费者消费
{
p.consume();
}
} }
public class ProducerConsumerDemo { public static void main(String[] args)
{
// 创建共享资源
Product p = new Product();
// 两个生产者,两个消费者
Producer producer = new Producer(p);
Consumer consumer = new Consumer(p);
Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer); Thread t2 = new Thread(consumer);
Thread t3 = new Thread(consumer); t0.start();
t1.start();
t2.start();
t3.start();
}
}

多次运行会发现,结果正是我们最初想要的:生产一个就消费一个!

原因很简单:notifyAll会唤醒线程池中所有的线程,假如t0生产了一次,就会唤醒t1,t2,t3,如果t1抢到cpu执行权就会判断标记等待,然后醒着的消费线程抢到执行权, 就去消费一次,然后唤醒所有等待的线程,同样,因为消费了一次,只要消费线程抢到cpu执行权就会根据标记去等待,生产者线程抢到cpu执行权就会判断标记,然后去生产,如此循环!至此,问题得到解决!

六、JDK1.5之后的新加锁方式 目录

在API文档中有一个Lock接口:

翻译:Lock 实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。

方法如下:

lock方法获取锁,unlock方法释放锁。

以前使用同步代码块和一个对象相结合的方式,实现线程同步,有了Lock接口以后,可以通过一个锁对象完成线程的同步。

使用Lock接口的一个已知实现类ReentrantLock来改写上面的多生产多消费程序,首先看看ReentrantLock的API文档里写的怎么用这个类:

而Lock接口的描述里面还提到:Lock 可以支持多个相关的 Condition 对象,Condition的API:

翻译:Condition将Object锁的监视器方法:wait,notify和notifyAll分解成截然不同的对象,以便通过将这些对象与任意Lock实现组合,为每个对象提供多个等待set.其中,Lock替代了synchronized方法和语句的使用,Condition替代了Object监视器方法的使用。

大致意思就是把这些锁的方法wait,notify和notifyAll封装在Condition中,而锁Lock和Condition是什么关系呢?在上面Lock方法的截图中:

即newCondition方法返回绑定到此Lock实例的新 Condition实例,所以Lock和Condition就是通过这个方法绑定一起,然后就能通过Condition实例调用与该锁想关的wait,notify和notifyAll方法。

但是注意wait,notify和notifyAll方法在Condition中的名称有所改变,但是功能是一样的:

好了,根据上面的知识,得出修改的代码:

 package thread.demo;

 import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; /*
* 生产者消费者问题
*/
class NewProduct
{
private String name;// 产品名称
private int number = 1; // 产品编号
private boolean notEmpty = false; // 创建一个锁对象
Lock lock = new ReentrantLock(); // 通过已有的锁获取该锁上的监视器对象
Condition c = lock.newCondition();
public void produce(String name)
{
lock.lock();
try
{
//如果有产品,可以停止生产一会
while (notEmpty)
{
/*
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
*/ try {
c.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果没有产品,就无需等待,直接生产
// 生产的产品名称
this.name = name + number;
// 编号递增
number++;
// 输出生产的产品信息:线程名(对应在某一个生产者)+产品名
System.out.println(Thread.currentThread().getName() + " 生产出: " + this.name);
// 生产完了以后,就有了产品
notEmpty = true;
//通知其他线程
//notify();
//notifyAll();
c.signalAll();
}
finally
{
lock.unlock();
}
} public void consume()
{
lock.lock();
try
{
// 如果没有产品,无法消费,等待
while (!notEmpty)
{
/*
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
*/
try {
c.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//打印产品被消费的信息:线程名(对应着某一个消费者) + 产品名
System.out.println(Thread.currentThread().getName() + "消费了:-> " + this.name);
//消费完了,通知其他线程
notEmpty = false;
//notify();
//notifyAll();
c.signalAll();
}
finally
{
lock.unlock();
}
}
} // 创建生产者线程
class NewProducer implements Runnable
{
private NewProduct p;
NewProducer(NewProduct p2)
{
this.p = p2;
} public void run()
{
while (true)
{
p.produce("bread"); // 假如生产面包
}
} } //创建消费者线程
class NewConsumer implements Runnable
{
private NewProduct p;
NewConsumer(NewProduct p)
{
this.p = p;
} public void run()
{
while (true)//消费者消费
{
p.consume();
}
} }
public class LockDemo { public static void main(String[] args)
{
// 创建共享资源
NewProduct p = new NewProduct();
// 两个生产者,两个消费者
NewProducer NewProducer = new NewProducer(p);
NewConsumer NewConsumer = new NewConsumer(p);
Thread t0 = new Thread(NewProducer);
Thread t1 = new Thread(NewProducer); Thread t2 = new Thread(NewConsumer);
Thread t3 = new Thread(NewConsumer); t0.start();
t1.start();
t2.start();
t3.start();
}
}

七、多生产多消费问题的新解决办法 目录

之前采用同步代码块的时候 ,多个线程都放在同一个锁下面进行同步,而这个锁只能具有一组监视器(wait,notify,notifyAll),同时监视着生产线程和消费线程,比如说这个监视器的wait即能使生产线程处于等待,也可以使消费线程进入等待。同理: 唤醒方法notify和notifyAll对两种线程都起作用。目前线程别分为两类:一组线程(t0,t1)负责生产,一组线程(t2, t3)负责消费。

现在的思路: 用Lock接口,把两组(共计4个)线程放在同一个锁下同步,但是绑定两个监视器分别监视生产线程和消费线程。关键代码有注释:

 package thread.demo;

 import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; /*
* 生产者消费者问题
*/
class NewProduct
{
private String name;// 产品名称
private int number = 1; // 产品编号
private boolean notEmpty = false; // 创建一个锁对象
Lock lock = new ReentrantLock(); // 通过已有的锁获取该锁上的监视器对象
//Condition c = lock.newCondition();
//通过已有的锁获得两组监视器,一组监视生产者,一组监视消费者
Condition producerCon = lock.newCondition();
Condition consumerCon = lock.newCondition();
public void produce(String name)
{
lock.lock();
try
{
while (notEmpty)
{
try {
producerCon.await();//调用生产者监视,只对生产线程有效
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果没有产品,就无需等待,直接生产
// 生产的产品名称
this.name = name + number;
// 编号递增
number++;
// 输出生产的产品信息:线程名(对应在某一个生产者)+产品名
System.out.println(Thread.currentThread().getName() + " 生产出: " + this.name);
// 生产完了以后,就有了产品
notEmpty = true;
//通知其他线程
consumerCon.signal();//调用消费者监视器,只能唤醒消费者
}
finally
{
lock.unlock();
}
} public void consume()
{
lock.lock();
try
{
// 如果没有产品,无法消费,等待
while (!notEmpty)
{
try {
consumerCon.await();//调用消费者的监视器,使消费线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//打印产品被消费的信息:线程名(对应着某一个消费者) + 产品名
System.out.println(Thread.currentThread().getName() + "消费了:-> " + this.name);
//消费完了,通知其他线程
notEmpty = false;
//通知生产者
producerCon.signal();
}
finally
{
lock.unlock();
}
}
} // 创建生产者线程
class NewProducer implements Runnable
{
private NewProduct p;
NewProducer(NewProduct p2)
{
this.p = p2;
} public void run()
{
while (true)
{
p.produce("bread"); // 假如生产面包
}
} } //创建消费者线程
class NewConsumer implements Runnable
{
private NewProduct p;
NewConsumer(NewProduct p)
{
this.p = p;
} public void run()
{
while (true)//消费者消费
{
p.consume();
}
} }
public class LockDemo { public static void main(String[] args)
{
// 创建共享资源
NewProduct p = new NewProduct();
// 两个生产者,两个消费者
NewProducer NewProducer = new NewProducer(p);
NewConsumer NewConsumer = new NewConsumer(p);
Thread t0 = new Thread(NewProducer);
Thread t1 = new Thread(NewProducer); Thread t2 = new Thread(NewConsumer);
Thread t3 = new Thread(NewConsumer); t0.start();
t1.start();
t2.start();
t3.start();
}
}

下面做一个简单的总结:

Lock接口:

  • 不用自己实现,查看API文档可以发现,库里面已经有几个已经实现了该接口的类,拿来用即可;
  • 它的替代了同步代码块或者同步函数;
  • 将同步的隐式操作变为显示操作;
  • 更为灵活,可以一个锁上加上多组监视器;
  • lock():获取锁
  • unlock:释放锁, 通常需要定义在finally代码块中(因为有时某些线程获取锁以后,程序在执行到unlock之前可能出现问题,但是别的线程还要执行,需要获取锁,所以必须保证锁能够得到释放)

Condition接口:

  • 替代了Object中的wait,notify和notifyAll方法,将这些监视器方法单独进行了封装,变成了Condition类型的监视器对象。
  • 可以和任意的锁组。
  • await();
  • signal();
  • signalAll();

下面看一看Java  Condition API文档中给出的范例,本人作出了简单的注释:

 package thread.demo;

 import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; class BoundedBuffer {
// 创建ReentrantLock锁对象lock
final Lock lock = new ReentrantLock();
// lock锁绑定一个监视器监视数组是否存满
final Condition notFull = lock.newCondition();
// lock锁绑定一个监视器监视数组是否为空
final Condition notEmpty = lock.newCondition();
// 建立一个可以存储100个任何对象的数组
final Object[] items = new Object[100];
int putptr, takeptr, count; // 向数组中填充对象 x,以供存储线程调用
public void put(Object x) throws InterruptedException {
lock.lock(); // 获取锁
try {
// 当数组存满,调用存满监视器的await,使存储线程等待
while (count == items.length)
notFull.await();
// 当数组没有存满,就存入一个对象
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
// 存储了对象之后,就去唤醒下面的取出元素的线程
// 大白话就是:俺里面不是空的,你可以来取元素了
notEmpty.signal();
} finally {
lock.unlock();
}
} // 取出元素的函数,以供取元素线程调用
public Object take() throws InterruptedException {
// 获取锁
lock.lock();
try {
// 当元素个数为0 时,通知取元素线程等待
// 大白话:里面是空的了,你等会再来取!
while (count == 0)
notEmpty.await();
// 当元素个数不为0,取出元素
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
// 取出一个元素之后,就通知存储线程
// 大白话:里面没有满,你可以来存元素了!
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}

八、sleep和wait的区别 目录

  • wait可以指定时间,也可以不指定时间,sleep必须指定时间
  • 在同步时,对于cpu执行权和锁的处理不同,
    • wait:释放执行权,释放锁
    • sleep:释放执行权,不释放锁

九、停止线程的方式 目录

  • stop
  • run方法结束

在任务中通常都有循环结构,只要控制住循环就可以结束任务。

控制循环通常就用定义标记来完成。

 package thread.demo;

 class StopThread implements Runnable
{
private boolean flag = true;
public void run ()
{
while (flag)
{
System.out.println(Thread.currentThread().getName() + " run...");
}
} public void setFlag()
{
flag = false;
}
}
public class StopThreadDemo
{
/**
* @param args
*/
public static void main(String[] args)
{
StopThread st = new StopThread();
Thread t0 = new Thread(st);
Thread t1 = new Thread(st);
t0.start();
t1.start(); for (int x = 0; x < 50; x++)
{
if (x == 49)
{
st.setFlag();
break;
}
System.out.println(Thread.currentThread().getName() + "..." + x);
}
System.out.println("over");
} }

可以看出,虽然主线程结束了,但是其他线程还要执行,然后根据标志位,自己停止。如果不设置标记,如果主线程over,其他线程就无法停止了。如果我们把第34行的改为x == 50,即这个条件就无法满足,标记为无法改变,虽然主线程结束,但是自定义的线程会继续执行。

假如把上面的程序改为如下:

 package thread.demo;

 class StopThread implements Runnable
{
private boolean flag = true;
public synchronized void run ()
{
while (flag)
{
try {
wait();
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + "..." + e);
} System.out.println(Thread.currentThread().getName() + " run...");
}
} public void setFlag()
{
flag = false;
}
}
public class StopThreadDemo
{
/**
* @param args
*/
public static void main(String[] args)
{
StopThread st = new StopThread();
Thread t0 = new Thread(st);
Thread t1 = new Thread(st);
t0.start();
t1.start(); for (int x = 0; x < 50; x++)
{
if (x == 49)
{
st.setFlag();
break;
}
System.out.println(Thread.currentThread().getName() + "..." + x);
}
System.out.println("over");
} }

发现主线程结束了,但是其他线程却没能停下来,很简单:线程0和线程1进入run之后,都在第11行被置为等待状态,而又没有其他线程来唤醒它们,于是一直等待,即使主线程结束,还是等待。

下面采用一种方法:

interrupt方法并不是字面上理解的中断线程(岂不是和stop一样?),注意红框中:如果线程在调用Object类的wait(), wait(long)或者wait(long, int)方法,或者该类的join(), join(long), join(long, int)或者sleep(long), sleep(long, int)方法过程中受阻,则这种受阻的状态会被强制清除,然后收到一个InterruptedException.

意思就是interrupt()方法,会把线程从wait或者sleep状态中强制恢复到运行状态中来,让线程具备cpu的执行资格,由于这个“强制”通常是不正常唤醒(正常唤醒notify/notifyAll),所以抛出异常InterruptedException,记得要处理!改动上面程序如下:

 package thread.demo;

 class StopThread implements Runnable
{
private boolean flag = true;
public synchronized void run ()
{
while (flag)
{
try {
wait();
} catch (InterruptedException e) {
// 打印异常信息
System.out.println(Thread.currentThread().getName() + "..." + e);
flag = false; // 处理异常
} System.out.println(Thread.currentThread().getName() + " run...");
}
} public void setFlag()
{
flag = false;
}
}
public class StopThreadDemo
{
/**
* @param args
*/
public static void main(String[] args)
{
StopThread st = new StopThread();
Thread t0 = new Thread(st);
Thread t1 = new Thread(st);
t0.start();
t1.start(); for (int x = 0; x < 50; x++)
{
if (x == 49)
{
//st.setFlag();
t0.interrupt();
t1.interrupt();
break;
}
System.out.println(Thread.currentThread().getName() + "..." + x);
}
System.out.println("over");
} }

看到线程都结束了,由于采用了interrupt方法,抛出了图示的异常!

十、守护线程 目录

首先还是看API文档关于守护线程的描述,Thread中的一个方法:

该方法将该线程标记为守护线程。当正在运行的线程都是守护线程的时候,Java 虚拟机退出。

该方法必须在启动线程前调用。

例如把上面代码的第47行的t1线程的中断注释掉,但是在在第38行将t1标记为守护线程(可以理解为后台线程):

 package thread.demo;

 class StopThread implements Runnable
{
private boolean flag = true;
public synchronized void run ()
{
while (flag)
{
try {
wait();
} catch (InterruptedException e) {
// 打印异常信息
System.out.println(Thread.currentThread().getName() + "..." + e);
flag = false; // 处理异常
} System.out.println(Thread.currentThread().getName() + " run...");
}
} public void setFlag()
{
flag = false;
}
}
public class StopThreadDemo
{
/**
* @param args
*/
public static void main(String[] args)
{
StopThread st = new StopThread();
Thread t0 = new Thread(st);
Thread t1 = new Thread(st);
t0.start();
t1.setDaemon(true);
t1.start(); for (int x = 0; x < 50; x++)
{
if (x == 49)
{
//st.setFlag();
t0.interrupt();
// t1.interrupt();
break;
}
System.out.println(Thread.currentThread().getName() + "..." + x);
}
System.out.println("over");
} }

由于线程t1没有能清除wait状态会一直等待,但是由于它是守护线程,Java虚拟机会退出,程序也会停止,但是t1线程就不会再抛出异常:

注意:守护线程运行时候正常线程一样,抢夺cpu执行权,就是在结束的时候,正常线程需要手动去结束:即stop,或者run方法结束等,但是守护线程是随着虚拟机退出而结束的。就好比我们的操作系统有很多后台进程是不允许我们去操作,在系统运行期间会一直存在并抢夺cpu执行权,但是他是随着系统关闭而停止的。

十一、线程的其他知识点  目录

 package thread.demo;

 class Demo implements Runnable
{
public void run ()
{
for (int i = 0; i < 50; i++)
{
System.out.println(Thread.currentThread().getName() + "..." + i);
}
}
}
public class JoinDemo
{ /**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException
{
Demo d = new Demo();
Thread t0 = new Thread(d);
Thread t1 = new Thread(d); t0.start();
t0.join(); // t0线程申请加入进来运行,此时主线程会释放执行权和执行资格。
t1.start();
//t0.join(); // t0线程申请加入进来运行,此时主线程会释放执行权和执行资格。 for (int i = 0; i < 50; i++)
{
System.out.println(Thread.currentThread().getName() + "..." + i);
}
} }

多次运行会发现,都是先执行线程0,这是因为线程0调用join方法之后,主线程会释放执行权和执行资格,一直等到线程0执行完,主线程才重新获取执行资格,如果是t1调用join方法,同理,主线程也会一直等待t1执行完才重新获取执行资格!

所以join方法常用来临时加入一个线程。

线程Thread有setPriority方法是用来设定线程的优先级,优先级越高,被随机执行的几率就越大!可以通过线程的toString方法看到线程权限:

 package thread.demo;

 class Demo implements Runnable
{
public void run ()
{
for (int i = 0; i < 50; i++)
{
System.out.println(Thread.currentThread().toString() + "..." + i);
}
}
}
public class JoinDemo
{ /**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException
{
Demo d = new Demo();
Thread t0 = new Thread(d);
Thread t1 = new Thread(d); t0.start();
t0.join(); // t0线程申请加入进来运行,此时主线程会释放执行权和执行资格。
t1.start();
//t0.join(); // t0线程申请加入进来运行,此时主线程会释放执行权和执行资格。 for (int i = 0; i < 50; i++)
{
System.out.println(Thread.currentThread().getName() + "..." + i);
}
} }

关于线程的优先级有三个字段:

所以setPriority(MAX_PRIORITY)和setPriority(10)的效果是一样的.

例如在上述代码中线程1启动后加入:

t1.setPriority(10);

还可以通过线程的构造函数将线程命名和将线程分组:

分组作用:加入有10个线程都处于等待状态,先要调用interrupt方法将这10个线程全部强制唤醒就需要调用10次,显然麻烦,如果将这10个线程封装在一个组里面,对着一个组调用interrupt就能够将组里面的线程全部进行中断状态清除(即唤醒)

还有一个方法:

暂停当前线程,释放执行权,避免某一个线程一直占有cpu执行权,用的不多.

参考:传智播客Java SE教程,李刚《疯狂Java讲义》

Java多线程技术学习笔记(二)的更多相关文章

  1. Java多线程技术学习笔记(一)

    目录: 概述 多线程的好处与弊端 JVM中的多线程解析 多线程的创建方式之一:继承Thread类 线程的状态 多线程创建的方式之二:实现Runnable接口 使用方式二创建多线程的好处 多线程示例 线 ...

  2. java之jvm学习笔记二(类装载器的体系结构)

    java的class只在需要的时候才内转载入内存,并由java虚拟机的执行引擎来执行,而执行引擎从总的来说主要的执行方式分为四种, 第一种,一次性解释代码,也就是当字节码转载到内存后,每次需要都会重新 ...

  3. Java多线程编程(学习笔记)

    一.说明 周末抽空重新学习了下多线程,为了方便以后查阅,写下学习笔记. 有效利用多线程的关键是理解程序是并发执行而不是串行执行的.例如:程序中有两个子系统需要并发执行,这时候需要利用多线程编程. 通过 ...

  4. 《深入理解Java虚拟机》学习笔记(二)

    垃圾回收的前提是判断对象是否存活,对象不再存活时将会被回收,下面是2种判断的方法. 引用计数法: 主流的Java虚拟机并没有使用引用计数法来管理内存,重要的原因就是循环引用的问题难以解决. 可达性分析 ...

  5. java 多线程——同步 学习笔记

      一.实例的同步方法 public synchronized void add(int value){ this.count += value; } Java 实例方法同步是同步在拥有该方法的对象上 ...

  6. Java多线程基础学习(二)

    9. 线程安全/共享变量——同步 当多个线程用到同一个变量时,在修改值时存在同时修改的可能性,而此时该变量只能被赋值一次.这就会导致出现“线程安全”问题,这个被多个线程共用的变量称之为“共享变量”. ...

  7. 【10-26】java调试技术学习笔记

    调试工具 jdk自带的工具 jmap jconsole VisualVM jmap jmap -histo:live pid 列出该进程的所有活动实例统计信息 jmap -dump:live,file ...

  8. 赶紧收藏!王者级别的Java多线程技术笔记,我java小菜鸡愿奉你为地表最强!

    Java多线程技术概述 介绍多线程之前要介绍线程,介绍线程则离不开进程. 首先 , 进程 :是一个正在执行中的程序,每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元: 线程:就 ...

  9. java之jvm学习笔记六-十二(实践写自己的安全管理器)(jar包的代码认证和签名) (实践对jar包的代码签名) (策略文件)(策略和保护域) (访问控制器) (访问控制器的栈校验机制) (jvm基本结构)

    java之jvm学习笔记六(实践写自己的安全管理器) 安全管理器SecurityManager里设计的内容实在是非常的庞大,它的核心方法就是checkPerssiom这个方法里又调用 AccessCo ...

随机推荐

  1. 20. Valid Parentheses

    1.题目: Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if th ...

  2. contesthunter CH Round #64 - MFOI杯水题欢乐赛day1 solve

    http://www.contesthunter.org/contest/CH Round %2364 - MFOI杯水题欢乐赛 day1/Solve Solve CH Round #64 - MFO ...

  3. 64位gcc编译32位汇编

    由于使用as和ld来编译链接汇编程序,在使用C库的时候比较麻烦,需要输入比较多的指令,所以使用gcc进行编译链接.由于书中内容是32位汇编程序,但是机器使用的是64位操作系统,自带的gcc也是64位的 ...

  4. Extjs springmvc session 超时 处理

    如果你的项目使用ExtJS作为表现层,你会发现,SESSION超时控制将是一个问题.本文将就自己的经验,来解决这一问题,当然,解决问题并非只有一种方法,我只是提出我的方法.首先,做超时控制,必需使用过 ...

  5. Struts2图片文件上传,判断图片格式和图片大小

    1. 配置Struts2能够上传的最大文件大小 使用Struts2进行文件上传的时候,Struts2默认文件大小最大为2MB,如果要传大一点的文件,就需要修改struts.xml配置文件,重新设置能够 ...

  6. 每天一个JS 小demo之树菜单。主要知识点:DOM方法综合运用,递归运用

    <!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"& ...

  7. BST性能分析&改进思路——平衡与等价

    极端退化 前面所提到的二叉搜索树,已经为我们对数据集进行高效的静态和动态操作打开了一扇新的大门.正如我们所看到的,BST从策略上可以看作是将之前的向量(动态数组)和链表结构的优势结合起来,不过多少令我 ...

  8. python config.ini的应用

    config.ini文件的结构是以下这样的:结构是"[ ]"之下是一个section,一部分一部分的结构.以下有三个section,分别为section0,section1,sec ...

  9. dom元素操作(动态事件绑定)

    遇到的问题:动态生成的内容,事件绑定会出错. 例子:http://snowinmay.net/jqm/dom-learn2.html 1.绑定事件对动态生成的新元素无效. 问题描述:bind事件绑定后 ...

  10. linux输入子系统

    linux输入子系统(linux input subsystem)从上到下由三层实现,分别为:输入子系统事件处理层(EventHandler).输入子系统核心层(InputCore)和输入子系统设备驱 ...