黑马程序员——Java基础---多线程
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
一、多线程
1.多线程概述
要研究多线程，我们首先要知道什么叫进程？说起进程大家应该比较熟悉，我们经常用任务管理器来管理我们计算机上运行的进程，如下图所示：
可以看到，计算机中每个正在运行的程序都至少创建了一条进程，有的甚至创建了多个进程如Chrome。
直白点说，进程就是一个正在进行中的程序。
每一个进程都有一个执行顺序，这个顺序是一个执行路径，或者叫做控制单元。
线程就是进程中独立的控制单元，线程控制着进程的执行，只要进程中有一个线程在执行，进程就不会停止。所以一个进程至少有一条线程存在。
那么多线程，顾名思义，就是对一个进程中多条线程同时运行的状态的描述。
举个比较大家熟知的例子，就是我们在执行一个java程序时，我们已经知道的除了执行main函数的那条线程外，还有一条负责垃圾回收的线程也在同时运行着。
通过这个例子我们也能了解到多线程存在的意义，试想一下，如果线程只能一个接一个按顺序执行，当代码比较多，形成了许多的空引用对象垃圾，但是负责垃圾回收的线程没有及时执行时，就会造成内存不足的现象，但如果能多线程，保持垃圾回收这条线程同时在执行，就可以及时的管理内存环境，所以多线程能让程序具有同时运行的效果，提高程序执行效率。
2.多线程创建
了解了多线程的好处，我们就要学会使用多线程，这里我们首先要学会创建多线程。
多线程创建主要有两种方式：继承和实现。下面我们一一介绍：
1.继承Thread方式
为什么要继承Thread类呢？具体要怎么做呢？
所以将查API养成一个习惯非常重要，因为API文档已经给了我们答案。
查找API文档，通过他的描述我们发现，原来java已经做了对线程这类事物的描述，所定义的类正是这个Thread，那么通过之前学过的知识，我们只要继承这个类就好了。（下图截自API文档）
这里有两点要注意：
1.为什么要重写run方法：因为Thread类中定义的run（）方法功能就是存储要执行多线程的代码。你想将哪些代码实现多线程，就将哪些代码写到run方法中。
2.为什么要写start()方法：调用这个线程的start方法的作用就是启动这个线程，如果你直接调用run方法，启动的还是一个线程，并不会实现多线程。
下面代码演示下：
/**
* 需求：创建多线程和主函数交替执行。
* 思路：继承Thread类，将要执行的代码存储进run方法
* @author jinlong
* */
package com.blog.part3.多线程;
//创建线程Test
class Test extends Thread
{
private String name;
//构造函数
Test(String name)
{
this.name=name;
}
//复写run方法，将要执行多线程的代码写进去
public void run()
{
for(int x=0;x<60;x++)
//这里说一些Thread.currentThread().getName()方法是为了获取正在运行的进程的名字
//每个进程在运行时都有默认名字，当然也可以人为赋予名字
System.out.println(this.name+".....正运行....."+x);
}
}
public class ThreadDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创键两个线程
Test a=new Test("线程一");
Test b=new Test("线程二");
//启动这两个线程
a.start();
b.start();
//设置下主线程执行的代码
for(int x=0;x<200;x++)
System.out.println("主线程运行ing");
}
}
我们可以看到，主函数和程序一、程序二明显的出现了交替打印的情况。我们可以知道，这三条线程是在同时执行的，只不过打印出来的时候存在先后。
2.实现Runnable接口
同样的我们去查API文档：
从这段话，我们可以看出，第二种创建线程的方法是为了弥补第一种方法的不足而开发出来的
总结下：
1.首先java是只支持单继承的，一个类已经继承了其他类那么就无法再继承Thread类了
2.Thread类本身也实现了Runnable接口，原来run方法其实来自Runnable接口。
3.再就是像API中所说的规范了，除非打算修改或增强类的基本行为，否则不该为该类创建子类。
下边举例具体创建过程：
/**
* 需求：用实现Runnble方式创建多线程，解决多窗口卖票问题。
* 思路：1.创建类实现Runnable接口，把代码写入run方法。
* 2.创建实现接口的子类实例对象。
* 3.将对象作为构造函数参数，创建四条不同线程并且启动。
* @author jinlong
* */
package com.blog.part3.多线程;
//创建Ticket类实现Runnable接口
class Ticket implements Runnable
{
//定义变量，表示票剩余量
private int tick=500;
@Override
//重写run方法
public void run()
{
while(true)
{
if(tick>0)
{
//显示当前线程以及剩余票
System.out.println(Thread.currentThread().getName()+"正在卖第"+tick--+"张票");
}
}
}
}
public class ThreadDemo1
{
public static void main(String[] args)
{
//创建对象
Ticket t=new Ticket();
//有多个窗口在同时卖票，创建多个Thread对象表示
//这里每个Thread对象就是一个Thread线程。
Thread t1=new Thread(t);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
Thread t4=new Thread(t);
//启动这四个线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}为什么要将Runnable接口的子类对象传递给Thread的构造函数？
因为，自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定对象的run方法，就必须明确该run方法所属对象。
通过上变代码，我们可以发现这四个进程在交替执行，注意如果没有交替出现，可能是初始票数量不够大。
总结下第二种方法的步骤：
创建步骤：
a、定义类实现Runnable的接口。
b、覆盖Runnable接口中的run方法。目的也是为了将线程要运行的代码存放在该run方法中。
c、通过Thread类创建线程对象。
d、将Runnable接口的子类对象作为实参传递给Thread类的构造方法。
e、调用Thread类中start方法启动线程。start方法会自动调用Runnable接口子类的run方法。
实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。
二、同步
上边我们讲了什么是多线程，以及怎么创建多线程，现在我们接着研究多线程的安全性问题。
1.安全问题
1.线程状态
想要研究同步我们首先要知道线程的几种存在状态：
被创建：等待启动，调用start启动。
运行状态：具有执行资格和执行权。
临时状态（阻塞）：有执行资格，但是没有执行权。
冻结状态：遇到sleep( )方法和wait( )方法时，失去执行资格和执行权，sleep方法时间到或者调用notify()方法唤醒时时，获得执行资格，变为 临时状态。
消忙状态：stop( )方法，或者run方法结束。
图解：
2.产生原因
为什么线程会有安全问题呢？ 比如上边我们举的四个窗口同时卖票的例子，有时会出现这种结果
Thread-2已经把最后一张票卖掉了，但是后边其他三个线程又个卖了一张票出现了负数票。出现这种情况的原因，在代码这一部分：
if(tick>0)
{
//显示当前线程以及剩余票
System.out.println(Thread.currentThread().getName()+"正在卖第"+tick-- +"张票");
}总结下：
1. 多个线程在操作共享的数据。
2. 操作共享数据的线程有多条。当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。
2.同步
针对上边出现的问题，怎么解决呢？
思路：对多条操作共享数据的语句，只能让一个线程都执行完。在执 行过程中，其他线程不可以参与执行。
在java中对于多线程的安全问题提供了专业的解决方式——synchronized（同步）。
同步也有两种实现方式：同步代码块和同步函数。都是利用关键字synchronized来实现。
1.同步代码块
用法：
synchronized（对象）
{需要被同步的代码}
同步可以解决安全问题的根本原因就在那个对象上。其中对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
示例：
/*
给卖票程序示例加上同步代码块。
*/
class Ticket implements Runnable
{
private int tick=100;
Object obj = new Object();
public void run()
{
while(true)
{
//给程序加同步，即锁
synchronized(obj)
{
if(tick>0)
{
try
{
//使用线程中的sleep方法，模拟线程出现的安全问题
//因为sleep方法有异常声明，所以这里要对其进行处理
Thread.sleep(10);
}
catch (Exception e)
{
}
//显示线程名及余票数
System.out.println(Thread.currentThread().getName()+"..tick="+tick--);
}
}
}
}
}
上图代码显示安全问题已被解决，原因在于Object对象相当于是一把锁，只有抢到锁的线程，才能进入同步代码块向下执行。因此，当tick=1时，CPU切换到某个线程后，如上图的Thread-3线程，其他线程将无法通过同步代码块继而进行if判断语句，只有等到Thread-3线程执行完“tick--”操作（此后tick的值为0），并且跳出同步代码块后，才能抢到锁。其他线程即使抢到锁，然而，此时tick值已为0，也就无法通过if语句判断，从而无法再执行“tick--”的操作了，也就不会出现0、-1、-2等情况了。
2.同步函数
格式：
在函数上加上synchronized修饰符即可。
那么同步函数用的是哪一个锁呢？
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。
示例：
class Ticket implements Runnable
{
private int tick=100;
Object obj = new Object();
public void run()
{
while(true)
{
show();
}
}
//直接在函数上用synchronized修饰即可实现同步
public synchronized void show()
{
if(tick>0)
{
try
{
//使用线程中的sleep方法，模拟线程出现的安全问题
//因为sleep方法有异常声明，所以这里要对其进行处理
Thread.sleep(10);
}
catch (Exception e)
{
}
//显示线程名及余票数
System.out.println(Thread.currentThread().getName()+"..tick="+tick--);
}
}
}
上图代码，Synchronized锁住了show函数，控制了不同线程对象对show函数调用，同样解决了安全问题。
3.同步的利弊
1、同步的前提
a，必须要有两个或者两个以上的线程。
b，必须是多个线程使用同一个锁。
2、同步的利弊
好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。
3、如何寻找多线程中的安全问题
a，明确哪些代码是多线程运行代码。
b，明确共享数据。
c，明确多线程运行代码中哪些语句是操作共享数据的。
4.静态同步
上边我们一直再说，同步的关键是锁住对象，那么当遇到静态函数时怎么办呢？ 是谁在使用函数的锁呢？
通过验证，发现不在是this。因为静态方法中也不可以定义this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。如：
类名.class 该对象的类型是Class或者 this.getClass
这就是静态函数所使用的锁。而静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class
/*
加同步的单例设计模式————懒汉式
*/
class Single
{
private static Single s = null;
private Single(){}
//函数被静态修饰了
public static void getInstance()
{
if(s==null)
{
//使用锁的对象其实是Single.class
synchronized(Single.class)
{
if(s==null)
s = new Single();
}
}
return s;
}
}
3.同步下的单例模式
恶汉式：不存在安全问题。因为不存在多个线程共同操作数据的问题。
class Single{
private static final Single s = new Single();
private Single(){}
public static Single getInstance(){
return s ;
}
}
class Single{
private static Single s = null;
private Single(){}
public static Single getInstance(){
if(s ==null){
synchronized(Single.class){
if(s == null)
s = new Single();
}
}
return s ;
}
}
懒汉式存在安全问题，可以使用同步函数解决。
但若直接使用同步函数，则效率较低，因为每次都需要判断。
双重否定的方法：
任何一个线程在执行到第一个if判断语句时，如果Single对象已经创建，则直接获取即可，而不用判断是否能够获取锁，相对于上面使用同 步函数的方法就提升了效率。如果当前线程发现Single对象尚未创建，则再判断是否能够获取锁。
1. 如果能够获取锁，那么就通过第二个if判断语句判断是否需要创建Single对象。因为可能当此线程获取到锁之前，已经有一个线程创建完 Single对象，并且放弃了锁。此时它便没有必要再去创建，可以直接跳出同步代码块，放弃锁，获取Single对象即可。如果有必要，则再创建。
2. 如果不能获取到锁，则等待，直至能够获取到锁为止，再按步骤一执行。
当然这种办法也并不是很完美，
参考连接：http://www.infoq.com/cn/articles/double-checked-locking-with-delay-initialization/
4.死锁
当同步中嵌套同步时，就会出现死锁。
示例1：
/**
* 需求：设计演示死锁
* 思路：利用标记更改判断条件，设计嵌套形成死锁
* @author jinlong
* */
package com.blog.part3.多线程;
class Ticket implements Runnable
{
private static int num = 100;
Object obj = new Object();
//设计标记flag控制状态
boolean flag = true;
public void run()
{
if(flag )
{
while(true )
{
//函数加锁
synchronized(obj )
{
show();
}
}
} else
while(true )
show();
}
//函数上加锁
public synchronized void show()
{
synchronized(obj )
{
if(num > 0)
{
//异常处理
try{
//休眠200毫秒
Thread. sleep(200);
} catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...function..." + num--);
}
}
}
}
class DeadLockDemo
{
public static void main(String[] args)
{
//实例化。
Ticket t = new Ticket();
//创键两个线程。
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try{
Thread. sleep(200);
} catch(InterruptedException e){
e.printStackTrace();
}
//改变标记状态
t. flag = false ;
t2.start();
}
}
运行结果：
分析形成原因：上边代码，会出现一种情况，线程1启动时，flag为true，那么线程1通过了if语句判断，执行到obj对象锁 ，将要执行show函数。与此同时，线程2也启动了，这时flag改为了false，那么线程2通过else语句执行了show函数，但是show函数本身也有同步锁，当线程2也执行到show函数的获取obj锁这一步时，程序卡住了。
示例2：
/**
* 需求：演示死锁
* 思路：设计两个对象，每一个线程都要经过两个对象锁，但是两个对象锁的执行顺序不同。
* 预期中目标是：线程1加载了a锁正要用b锁，于此同时线程2加载了b锁正要用a锁。
* 这样a,b两个对象锁都有人使用同时又都需要被使用。形成死锁
* @author jinlong
* */
package com.blog.part3.多线程;
//定义Test类
class Test implements Runnable{
//私有函数控制Test状态
private boolean flag ;
//根据传入值初始化flag
Test( boolean flag){
this.flag = flag;
}
public void run()
{
//根据flag值，将两条线程分开
if(flag ){
while(true )
//这里先执行locka对象锁
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName() + "...if locka...");
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName() + "...if lockb...");
}
}
} else{
while(true )
//这里先执行lockb对象锁
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName() + "...else lockb...");
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName() + "...else locka...");
}
}
}
}
}
class MyLock{
//设计两个对象locka和lockb
public static final Object locka = new Object();
public static final Object lockb = new Object();
}
class DeadLockDemo1{
public static void main(String[] args){
//根据传入参数，赋予ab两个线程不同路线。
Test a = new Test(true );
Test b = new Test(false );
Thread t1 = new Thread(a);
Thread t2 = new Thread(b);
t1.start();
t2.start();
}
}
三、线程间通信
1.基本概念
多个线程在处理统一资源，但是任务却不同，这时候就需要线程间通信。
等待/唤醒机制涉及的方法：
1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。
2. notify()：唤醒线程池中的一个线程（任何一个都有可能）。
3. notifyAll()：唤醒线程池中的所有线程。
P.S.
1、这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。
2、必须要明确到底操作的是哪个锁上的线程！
3、wait和sleep区别？
1）wait可以指定时间也可以不指定。sleep必须指定时间。
2）在同步中时，对CPU的执行权和锁的处理不同。
wait：释放执行权，释放锁。
sleep：释放执行权，不释放锁。
为什么操作线程的方法wait、notify、notifyAll定义在了object类中，因为这些方法是监视器的方法，监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定在object类中
等待/唤醒机制涉及的方法：
1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。
2. notify()：唤醒线程池中的一个线程（任何一个都有可能）。
3. notifyAll()：唤醒线程池中的所有线程。
P.S.
1、这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。
2、必须要明确到底操作的是哪个锁上的线程！
3、wait和sleep区别？
1）wait可以指定时间也可以不指定。sleep必须指定时间。
2）在同步中时，对CPU的执行权和锁的处理不同。
wait：释放执行权，释放锁。
sleep：释放执行权，不释放锁。
为什么操作线程的方法wait、notify、notifyAll定义在了object类中，因为这些方法是监视器的方法，监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定在object类中
2.经典案例
经典案例一：
/**
* 需求：间隔打印mike和lili的信息，
* 思路：设计两个线程，控制这两个线程有规律的交替执行，
* 同时要保证每一条数据的完整性。不能出现名字性别不对应情况。
*@author jinlong
* */
package com.blog.part3.多线程;
//定义Person类
class Person{
//定义Person两个基本属性，name和sex
private String name ;
private String sex ;
//定义标记
private boolean flag = false;
//set方法用来修改Person属性信息
public synchronized void set(String name,String sex)
{
if(flag )
try{
//冻结当前线程进入
this.wait();
} catch(InterruptedException e){
e.printStackTrace();
}
this.name = name;
this.sex = sex;
flag = true ;
//唤醒其他线程
this.notify();
}
//out方法用来打印输出name和sex
public synchronized void out()
{
if(!flag )
try{
this.wait();
} catch(InterruptedException e){
e.printStackTrace();
}
System. out.println(name + "..." + sex);
flag = false ;
this.notify();
}
}
//输入类，实现Runnable，保证对Person属性的修改能同步
class Input implements Runnable
{
Person r;
Input(Person r){
this.r = r;
}
public void run(){
int x = 0;
while(true ){
if(x == 0){
r.set( "mike","男" );
} else{
r.set( "lili","女" );
}
//实现交替输入mike和lili
x = (x + 1)%2;
}
}
}
//定义输出类，同样保证输出信息的对应
class Output implements Runnable{
Person r;
Output(Person r){
this.r = r;
}
public void run(){
while(true ){
r.out();
}
}
}
class PersonDemo {
public static void main(String[] args){
//创建资源
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 com.blog.part3.多线程;
//定义Res类代表产品
class Res
{
//定义私有属性name代表产品名字
private String name;
//变量count代表产品当前数量
private int count;
private boolean flag=false;
//生产方法，即生产产品，函数同步
public synchronized void shengChan(String name)
{
while(flag)
try
{
wait();
}
catch (Exception e)
{
}
//产品名为：传入参数+产品ID+当前数量
this.name = name +"产品ID"+count++;
//打印当前线程名，以及当前线程生产的产品名字
System.out.println(Thread.currentThread().getName()+"......生产者++++"+this.name);
flag = true;
//唤醒其他线程
notifyAll();
}
//定义xiaofei方法，同样函数同步
public synchronized void xiaoFei()
{
while(!flag)
try
{
wait();
}
catch (Exception e)
{
}
//打印当前线程作为消费者
System.out.println(Thread.currentThread().getName()+"......消费者"+this.name);
flag=false;
//唤醒其他线程
notifyAll();
}
}
//定义消费者类，用来增加产品量
class Produce implements Runnable
{
//私有成员变量Res类型的r
private Res r;
//通过构造函数给r赋值
Produce(Res r)
{
this.r=r;
}
public void run()
{
while(true)
{
//将生产者的生产动作写如run方法
r.shengChan("++制造商品++");
}
}
}
//定义消费者
class Consumer implements Runnable
{
//私有成员 r
private Res r;
//通过构造函数给r赋值
Consumer(Res r)
{
this.r=r;
}
public void run()
{
while(true)
{
//消费者行为
r.xiaoFei();
}
}
}
class ProConDemo
{
public static void main(String[] args)
{
//创建Res的唯一对象r
Res r= new Res();
//创建生产者对象p和消费者对象c，并且他们初始化参数值都为r
Produce p= new Produce(r);
Consumer c= new Consumer(r);
//给生产者定义两个线程，即有两个生产者
Thread t1= new Thread (p);
Thread t2= new Thread (p);
//给消费者定义两个线程，即两个消费者。
Thread t3= new Thread (c);
Thread t4= new Thread (c);
//启动线程。
t1.start();
t2.start();
t3.start();
t4.start();
}
}
对比示例一，有两个变化：
1.notify变成了notifyAll：因为示例二生产者和消费者各有两个线程，而notify只能唤醒一个线程，如果唤醒的是本方的线程那么会形成死锁，没有意义。
2.if判断变成了while。因为if判断标记只有一次，会导致不该运行的语句运行了，而while则是只有满足条件的才会执行。
3.JDK1.5新特性
1.Lock锁
同步代码块对于锁的操作是隐式的。
JDK1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作。
Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式操作变成显示锁操作。同时更为灵活，可以一个锁上加上多组监视器。
lock()：获取锁。
unlock()：释放锁，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在finally中。
Condition接口：出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象，可以 任意锁进行组合。
Condition接口中的await方法对应于Object中的wait方法。
Condition接口中的signal方法对应于Object中的notify方法。
Condition接口中的signalAll方法对应于Object中的notifyAll方法。
JDK1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作。
Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式操作变成显示锁操作。同时更为灵活，可以一个锁上加上多组监视器。
lock()：获取锁。
unlock()：释放锁，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在finally中。
Condition接口：出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象，可以 任意锁进行组合。
Condition接口中的await方法对应于Object中的wait方法。
Condition接口中的signal方法对应于Object中的notify方法。
Condition接口中的signalAll方法对应于Object中的notifyAll方法。
示例：
/**
* 需求：1.生产者生产商品，供消费者使用 有两个或者多个生产者，生产一次就等待消费一次
有两个或者多个消费者，等待生产者生产一次就消费掉 。
2.使用Lock、Condition
思路：定义资源类，存取方法通过Lock实现同步
定义生产者和消费者，各自实现Runnable接口，实现对资源类的同步操作
* */
package com.blog.part3.多线程;
//使用Lock需要导入包
import java.util.concurrent.locks.*;
//定义产品资源类
class Resource
{
//定义产品属性变量name和count
private String name;
private int count=1;
//标记
private boolean flag = false;
//多态
private Lock lock=new ReentrantLock();
//创建两Condition对象，分别来控制等待或唤醒本方和对方线程
Condition condition_pro=lock.newCondition();
Condition condition_con=lock.newCondition();
//定义生产者使用的方法，产品增加
//p1、p2共享此方法
public void setProducer(String name)throws InterruptedException
{
lock.lock();//加锁
try
{
while(flag)//重复判断标识，确认是否生产
condition_pro.await();//本方等待
this.name=name+"......"+count++;//生产
System.out.println(Thread.currentThread().getName()+"...生产..."+this.name);//打印生产
flag=true;//控制生产\消费标识
condition_con.signal();//唤醒对方
}
finally
{
lock.unlock();//解锁，这个动作一定执行
}
}
//c1、c2共享此方法
public void getConsumer()throws InterruptedException
{
lock.lock(); //
try
{
while(!flag)//重复判断标识，确认是否可以消费
condition_con.await();
System.out.println(Thread.currentThread().getName()+".消费."+this.name);//打印消费
flag=false;//控制生产\消费标识
condition_pro.signal();
}
finally
{
lock.unlock();
}
}
}
//生产者线程
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res=res;
}
//复写run方法
public void run()
{
while(true)
{
try
{
res.setProducer("商品");
}
catch (InterruptedException e)
{
}
}
}
}
//消费者线程
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res=res;
}
//复写run
public void run()
{
while(true)
{
try
{
res.getConsumer();
}
catch (InterruptedException e)
{
}
}
}
}
class ProConDemo1
{
public static void main(String[] args)
{
Resource res=new Resource();
new Thread(new Producer(res)).start();//第一个生产线程 p1
new Thread(new Consumer(res)).start();//第一个消费线程 c1
new Thread(new Producer(res)).start();//第二个生产线程 p2
new Thread(new Consumer(res)).start();//第二个消费线程 c2
}
}
2.停止线程
在JDK 1.5版本之前，有stop停止线程的方法，但升级之后，此方法已经过时。
如果停止线程，只有一种办法，那就是让run方法结束。
1、开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。
如：run方法中有如下代码，设置一个flag标记。那么只要在主函数或者其他线程中，在该线程执行一段时间后，将标记flag赋值false，该run方法就会结束，线程也就停止了。
public void run()
{
while(flag)
{
System.out.println(Thread.currentThread().getName()+"....run");
}
} 当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。Thread类提供该方法interrupt();
package com.blog.part3.多线程;
class StopThread implements Runnable
{
private boolean flag =true;
public void run()
{
while(flag)
{
System.out.println(Thread.currentThread().getName()+"....run");
}
}
public void changeFlag()
{
flag = false;
}
}
class StopThreadDemo
{
public static void main(String[] args)
{
StopThread st = new StopThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t2.start();
int num = 0;
while(true)
{
if(num++ == 60)
{
t1.interrupt();//清除冻结状态
t2.interrupt();
st.changeFlag();//改变循环标记
break;
}
System.out.println(Thread.currentThread().getName()+"......."+num);
}
System.out.println("over");
}
} 四、线程类其他方法
1.setDaemon方法：
概念/目的：后台线程主要是为其他线程（相对可以称之为前台线程）提供服务，或“守护线程”。如JVM中的垃圾回收线程。
生命周期：后台线程的生命周期与前台线程生命周期有一定关联。主要体现在：当所有的前台线程都进入死亡状态时，后台线程会自动死亡(其实这 个也很好理解，因为后台线程存在的目的在于为前台线程服务的，既然所有的前台线程都死亡了，那它自己还留着有什么用)。
设置后台线程：调用Thread对象的setDaemon(true)方法可以将指定的线程设置为后台线程。
/**
* 需求：演示守护线程
* 思路:1.设计一个永真死循环，不打扰情况下不断自增
* 2.不使用线程守护时，循环会一直进行下去
* 3.对这个死循环线程使用守护后，当主函数结束时，死循环也结束
* @author jinlong
* */
package com.blog.part3.多线程;
import java.io.IOException;
class DaemoDemo extends Thread
{
public void run()
{
//永真循环线程
for(int i=0;;i++){
try {
//间隔1000毫秒
Thread.sleep(1000);
} catch (InterruptedException ex) { }
System.out.println(i);
}
}
public static void main(String [] args)
{
DaemoDemo test = new DaemoDemo();
test.setDaemon(true); //调试时可以设置为false，那么这个程序是个死循环，没有退出条件。设置为true，即可主线程结束，test线程也结束。
test.start();
System.out.println("isDaemon = " + test.isDaemon());
try {
System.in.read(); // 接受输入，使程序在此停顿，一旦接收到用户输入，main线程结束，守护线程自动结束
} catch (IOException ex) {}
}
}2.join方法
当A线程执行到了b线程的.join（）方法时，A线程就会等待，等B线程都执行完，A线程才会执行。（此时B和其他线程交替运行。）join可以用来临时加入线程执行。
/**
*需求：演示join的使用
*思路：创建一个线程，进行固定次数循环，主线程设计同样的固定次数循环
* 比较使用join和不使用join的变换
* */
package com.blog.part3.多线程;
public class JoinDemo extends Thread
{
public void run()
{
//for循环50次
for(int i=0;i<50;i++)
{
try
{
Thread.sleep(1000);
}
catch(InterruptedException ex){}
System.out.println("Test"+i);
}
}
public static void main(String [] args)
{
JoinDemo test=new JoinDemo();
test.start();
//加入join方法后，main线程会在test执行完之后才执行，不会抢走他的执行权
try {
test.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<50;i++)
{
System.out.println("main"+i);
}
}
}
3.setPriority方法
Java中，线程的优先级是介于Thread.MIN_PRIORITY到Thread.MAX_PRIORITY这两个常量之间的某个整数数值（介于1到10之间）。当利用某一线程又创建了一个新线程对象时，这个新线程将拥有与创建它的线程一样的优先级。例如，主线程的优先级默认情况下是5，那么利用主线程创建的新线程的优先级默认情况下也是5。
这里要注意一点：具有较高线程优先级的对象，只是具有较多的执行机会，而非优先执行。
MAX_PRIORITY 最高优先级10
MIN_PRIORITY 最低优先级1
NORM_PRIORITY 分配给线程的默认优先级5
Mix t1 = new Mix("Thread 1");
Mix t2 = new Mix("Thread 2");
Mix t3 = new Mix ("Thread 3");
t1.setPriority(Thread.NORM_PRIORITY-3); //设置优先级为2
t2.setPriority(Thread.NORM_PRIORITY+3); //设置优先级为8
t3.setPriority(Thread.MAX_PRIORITY);//设置优先级为104. toString方法
5.yield方法
示例：
/**
* 需求：演示yield方法的使用
* 思路：1.设计两个优先级不同的线程myThread1和myThread2
* 2.主函数设计一个循环打印输出，当变量值满足条件时，开启两个线程，同时主函数调用yield方法。
* 3.多次运行，看是否有控制作用
* @author jinlong
* */
package com.blog.part3.多线程;
public class YiledDemo
{
public static void main(String[] args)
{
//创建两个线程
Thread myThread1 = new MyThread1();
Thread myThread2 = new MyThread2();
//设置两个线程不同的优先级
myThread1.setPriority(Thread.MAX_PRIORITY);
myThread2.setPriority(Thread.MIN_PRIORITY);
//主函数线程中进行的for循环
for (int i = 0; i < 100; i++)
{
//主线程进行打印
System.out.println("main thread i = " + i);
//当i=20时，进行判断
if (i == 20)
{
//启动两个线程
myThread1.start();
myThread2.start();
//让主函数线程让步
Thread.yield();
}
}
}
}
class MyThread1 extends Thread
{
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("myThread 1 -- i = " + i);
}
}
}
class MyThread2 extends Thread
{
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("myThread 2 -- i = " + i);
}
}
}