黑马程序员——java编程那些事儿____多线程（二）

-------android培训、java培训、期待与您交流！
----------

一 多线程之间的通信

1，多线程间通信概述

多线程间通讯就是多个线程在操作同一资源,但是操作的动作不同.

(1)为什么要通信

多线程并发执行的时候, 如果需要指定线程等待或者唤醒指定线程, 那么就需要通信.比如生产者消费者的问题，

生产一个消费一个,生产的时候需要负责消费的进程等待,生产一个完成后需要唤醒负责消费的线程,

同时让自己处于等待，消费的时候负责消费的线程被唤醒，消费完生产的产品后又将等待的生产线程唤醒，

然后使自己线程处于等待。这样来回通信，以达到生产一个消费一个的目的。

(2)怎么通信

在同步代码块中, 使用锁对象的wait()方法可以让当前线程等待, 直到有其他线程唤醒为止.

使用锁对象的notify()方法可以唤醒一个等待的线程，或者notifyAll唤醒所有等待的线程.

多线程间通信用sleep很难实现，睡眠时间很难把握。

2，等待唤醒机制 wait()与notify()

（1）wait()、notify()、notifyAll()

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，

而是由JVM确定唤醒哪个线程(一般是最先开始等待的线程)，而且不是按优先级。

Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

注意：sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

（2）为什么wait()、notify()、notifyAll()这些用来操作线程的方法定义在Object类中？

(1)这些方法只存在于同步中；

(2)使用这些方法时必须要指定所属的锁，即被哪个锁调用这些方法，只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒，也即是说

等待和唤醒必须是同一个锁

(3)而锁可以是任意对象，所以任意对象调用的方法就定义在Object中。

/*
线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。
*/
class Res
{
private String name;
private String sex;
private boolean flag = false;

public synchronized void set(String name,String sex)
{
if(flag)
try{this.wait();}catch(Exception e){}
this.name = name;

this.sex = sex;
flag = true;
this.notify();
}
public synchronized void out()
{
if(!flag)
try{this.wait();}catch(Exception e){}
System.out.println(name+"........"+sex);
flag = false;
this.notify();
}
}

class Input implements Runnable
{
private Res r ;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
if(x==0)
r.set("mike","man");
else
r.set("丽丽","女女女女女");
x = (x+1)%2;
}
}
}

class Output implements Runnable
{
private Res r ;

Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
r.out();
}
}
}

class  InputOutputDemo2
{
public static void main(String[] args)
{
Res r = new Res();

new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
/*
Input in = new Input(r);
Output out = new Output(r);

Thread t1 = new Thread(in);
Thread t2 = new Thread(out);

t1.start();
t2.start();
*/
}
}

（3）生产者与消费者

/*
对于多个生产者和消费者为什么要定义while判断标记
原因就是让被唤醒的线程再一次判断标记

为什么要定义notifyAll
因为需要唤醒对方线程，因为只用notify容易出现只唤醒本方线程的情况，导致程序中
的所有线程都等待
*/

class  ProducerConsumerDemo
{
public static void main(String[] args)
{
Resource r = new Resource();
new Thread((new Producer(r))).start();
new Thread((new Consumer(r))).start();

}
}

class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name)
{
while(flag)
try{this.wait();}catch(Exception e){}
this.name = name+""+count++;
System.out.println(Thread.currentThread().getName()+"....生产者+..."+this.name);
flag = true;
this.notifyAll();
}
public synchronized void out()
{
while(!flag)
try{this.wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....消费者+..."+this.name);
flag = false;
this.notifyAll();
}
}

class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.set("+商品-");
}
}
}

class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.out();
}
}
}

（4）jdk1.5升级版本Lock和Condition

实现提供比synchronized方法和语句可获得的更广泛的锁的操作，可支持多个相关的Condition对象，Lock是个接口，锁是控制多个线程对共享数据进行访问的工具。

JDK1.5中提供了多线程升级的解决方案：

将同步synchonized替换成了显示的Lock操作，将Object中的wait、notify、notifyAll替换成了Condition对象。

该对象可以Lock锁进行获取

Lock的方法摘要：

void lock() 获取锁。

Condition newCondition() 返回绑定到此 Lock 实例的新 Condition 实例。

void unlock() 释放锁。

Condition方法摘要：

void await() 造成当前线程在接到信号或被中断之前一直处于等待状态。

void signal() 唤醒一个等待线程。

void signalAll() 唤醒所有等待线程。

/*
jdk1.5 新版本 提供了多线程的解决方案
将同步synchronized替换成现实lock操作
将object中的wait，notify notifyAll，替换成了condition对象
该对象可以Lock锁进行获取。
该实例中，实现了本方只唤醒对方的操作
*/
import java.util.concurrent.locks.*;
class  ProducerConsumerDemo2
{
public static void main(String[] args)
{
Resource r = new Resource();
new Thread((new Producer(r))).start();
new Thread((new Consumer(r))).start();

}
}
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;

private Lock lock = new ReentrantLock();

private Condition condition_pro = lock.newCondition();
private Condition condition_con = lock.newCondition();

public  void set(String name)throws InterruptedException
{
lock.lock();
try
{
while(flag)
condition_por.await();
this.name = name+""+count++;
System.out.println(Thread.currentThread().getName()+"....生产者..."+this.name);
flag = true;

condition_con.signalAll();
}
finally
{
lock.unlock();//释放锁的动作一定要执行。
}

}
public  void out()throws InterruptedException
{
lock.lock();
try
{
while(!flag)
condition_con.await();
System.out.println(Thread.currentThread().getName()+"....消费者..."+this.name);
flag = false;
condition_pro.signalAll();
}
finally
{
lock.unlock();
}

}
}

class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.set("+商品-");
}
catch (InterruptedException e)
{
}

}
}
}

class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.out();
}
catch (InterruptedException e)
{
}
}
}
}

二 线程的操作

1 停止线程

stop方法已经过时，如何停止线程？

停止线程的方法只有一种，就是run方法结束。如何让run方法结束呢？

开启多线程运行，运行代码通常是循环体，只要控制住循环，就可以让run方法结束，也就是结束线程。

特殊情况：当线程属于冻结状态，就不会读取循环控制标记，则线程就不会结束。

为解决该特殊情况，可引入Thread类中的Interrupt方法结束线程的冻结状态；

当没有指定的方式让冻结线程恢复到运行状态时，需要对冻结进行清除，强制让线程恢复到运行状态

2 void interrupt() 中断线程:

中断状态将被清除，它还将收到一个 InterruptedException

3 setDaemon(boolean on) 守护线程（后台线程）

setDaemon(boolean on):将该线程标记为守护线程或者用户线程。

当主线程结束，守护线程自动结束，比如圣斗士星矢里面的守护雅典娜，

在多线程里面主线程就是雅典娜，守护线程就是圣斗士，主线程结束了，守护线程则自动结束。

当正在运行的线程都是守护线程时，java虚拟机jvm退出；所以该方法必须在启动线程前调用；

守护线程的特点：

守护线程开启后和前台线程共同抢夺cpu的执行权，开启、运行两者都没区别，

但结束时有区别，当所有前台线程都结束后，守护线程会自动结束。

/*
stop方法已经过时

如何停止线程？
只有一种方法，run方法结束。
开启多线程运行，运行代码是循环结构。
只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊清况:
当线程处于了冻结状态就不会读取到标记，那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除（interrupt）。
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

Thread类中提供了该方法 interrupt();
*/

class StopThread implements Runnable
{
private boolean flag = true;
public synchronized void run()
{
while (flag)
{
try
{
wait();//冻结
}
catch (InterruptedException e)//使用interrupt()会有这样的异常（相当于受伤了）
{
System.out.println(Thread.currentThread().getName()+".....Exception");
flag = false;//恢复到运行状态了，就可以使线程结束
}
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.setDaemon(true);//守护线程：当正在运行的线程都是守护线程时，java虚拟机退出，该方法必须在启动线程前调用
//t2.setDaemon(true);
t1.start();
t2.start();

int num = 0;
while(true)
{
if(num++ == 60)
{

t1.interrupt();//将处于冻结状态的线程强制清除
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"........."+num);
}
System.out.println("over");
}
}

4 join 加入一个线程

void join() 等待该线程终止。

void join(long millis) 等待该线程终止的时间最长为 millis 毫秒。throws InterruptedException

特点：当A线程执行到B线程的join方法时，A就会等待B线程都执行完，A才会执行

作用: join可以用来临时加入线程执行；

5 多线程优先级：yield()方法

yield():暂停当前正在执行的线程对象，并执行其他线程

setPriority(int newPriority):更改线程优先级

int getPriority() 返回线程的优先级。

String toString() 返回该线程的字符串表示形式，包括线程名称、优先级和线程组

(1)MAX_PRIORITY:最高优先级(10级)

(1)Min_PRIORITY:最低优先级(1级)

(1)Morm_PRIORITY:默认优先级(5级)

/*
Join：
当A线程执行到了B线程的join()方法时，A线程就会等待，等B线程都执行完，A才会执行。
join可以用来临时加入线程执行。
*/
class Demo implements Runnable
{
public void run()
{
for (int x=0;x<70 ;x++ )
{
System.out.println(Thread.currentThread().toString()+"...."+x);
Thread.yield();//临时释放用的，稍微减缓运行，而且能达到使线程平均运行的效果

}
}
}
class JoinDemo
{
public static void main(String[] args) throws Exception
{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();

//t1.join();//可以临时加入一个线程

//t1.setPriority(Thread.MAX_PRIORITY);//设置优先级

t2.start();

for (int x=0; x<80 ;x++ )
{
System.out.println("main..."+x);
}
System.out.println("over");
}
}

三 开发如何写线程

(1)开发这样写代码

//开发这样写多线程，使匿名内部类
class ThreadTest
{
public static void main(String[] args)
{
//一个线程
new Thread()
{
public void run()
{
for(int x=0;x<100;x++)
{
System.out.println(Thread.currentThread().getName()+"Hello"+x);
}
}
}.start();

//两个线程
for(int x=0;x<100;x++)
{
System.out.println(Thread.currentThread().getName()+"Hello"+x);
}

//三个线程
Runnable r = new Runnable()
{
public void run()
{
for(int x=0;x<100;x++)
{
System.out.println(Thread.currentThread().getName()+"Hello"+x);
}
}
};
new Thread(r).start();

/*new Test1().start();*/
}
}

/*
//还可单独建一个类，但是这样麻烦
class Test1 extends Thread
{
public void run()
{
for(int x=0;x<100;x++)
{
System.out.println(Thread.currentThread().getName()+"Hello"+x);
}
}
}

*/

（2）jdk1.5新特性创建线程

总结一下张孝祥老师两个面试题里的多线程

//计时器
//方式一
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable(){
public void run(){

}
},
1,
1,
TimeUnit.SECONDS
);
//方式二
ScheduledExectorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){
public void run(){

}
},
1,
1,
TimeUnit.SECONDS
);

//线程池
//方式一
Executors.newSingleThreadExector().execute(
new Runnable(){
public void run(){

}
}
);
//方式二
ExecutorService pool = Executors.newSingleThreadExecutor();
pool.execute(
new Runnable(){
public void run(){

}
}
);

四 多线程的其他问题

1、什么是ThreadLocal类,怎么使用它？

ThreadLocal类提供了线程局部 (thread-local) 变量。是一个线程级别的局部变量，并非“本地线程”。

ThreadLocal 为每个使用该变量的线程,提供了一个独立的变量副本，每个线程修改副本时不影响其它线程对象的副本

下面是线程局部变量(ThreadLocal variables)的关键点：

一个线程局部变量(ThreadLocal variables)为每个线程方便地提供了一个单独的变量。

ThreadLocal 实例通常作为静态的私有的(private static)字段出现在一个类中，这个类用来关联一个线程。

当多个线程访问 ThreadLocal 实例时，每个线程维护 ThreadLocal 提供的独立的变量副本。

常用的使用可在 DAO 模式中见到，当 DAO 类作为一个单例类时，

数据库链接(connection)被每一个线程独立的维护，互不影响。(基于线程的单例)

2、什么时候抛出InvalidMonitorStateException异常?为什么？

调用 wait ()/notify ()/notifyAll ()中的任何一个方法时，如果当前线程没有获得该对象的锁，那么就会抛出 IllegalMonitorStateException 的异常

也就是说程序在没有执行对象的任何同步块或者同步方法时，仍然尝试调用 wait ()/notify ()/notifyAll ()时。由于该异常是 RuntimeExcpetion 的子类，

所以该异常不一定要捕获(尽管你可以捕获只要你愿意作为 RuntimeException，此类异常不会在 wait (),notify (),notifyAll ()的方法签名提及。

3、在静态方法上使用同步时会发生什么事？

同步静态方法时会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。

4、当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？

可以，一个非同步方法总是可以被调用而不会有任何问题。实际上，Java 没有为非同步方法做任何检查，锁对象仅仅在同步方法或者同步代码块中检查。如果一个方法没有声明为同步，即使你在使用共享数据Java照样会调用，而不会做检查是否安全，所以在这种情况下要特别小心。一个方法是否声明为同步取决于临界区访问(critial section access)，如果方法不访问临界区(共享资源或者数据结构)就没必要声明为同步的。

5、在一个对象上两个线程可以调用两个不同的同步实例方法吗？

不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。所以只有执行完该方法释放对象锁后才能执行其它同步方法。

6、什么是线程饿死，什么是活锁？

线程饿死和活锁虽然不像死锁一样是常见的问题，但是对于并发编程的设计者来说就像一次邂逅一样。当所有线程阻塞，或者由于需要的资源无效而不能处理，不存在非阻塞线程使资源可用。

JavaAPI 中线程活锁可能发生在以下情形：

当所有线程在程序中执行 Object.wait (0)，参数为 0 的 wait 方法。程序将发生活锁直到在相应的对象上有线程调用 Object.notify ()或者Object.notifyAll ()。

当所有线程卡在无限循环中。

-------android培训、java培训、期待与您交流！
----------