JavaSE实战——多线程

转载请声明出处：http://blog.csdn.net/zhongkelee/article/details/45892177

说在前面

    在介绍java的多线程技术之前，我们先来看一下几个概念。

    硬盘：持久化数据存储设备（寻道，磁盘磁头，运算速度慢）
    内存：临时性数据存储设备（寻址，颗粒晶片，运算速度快）<-- CPU过来运算

    进程：就是应用程序在内存中分配的空间。（正在运行中的程序）
    线程：是进程中负责程序执行的执行单元。也成为执行路径，控制单元。
    进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。一个进程中至少有一个线程在负责该进程的运行。如果一个进程中出现了多个线程，就称该程序为多线程程序。
    举例：运动场--鸟巢。水立方。

    多线程技术：解决多部分代码同时执行的需求。可以合理地使用cpu资源。

    单核cpu：
    相比多核，单核不具备真正的线程级并行能力。
    比如在单核上开了多个线程，这多个线程是会分时使用CPU的，在某一时刻，单核只可能为某一个线程服务，不存在并行。
    只是cpu以ms级甚至更低的时间片的方式在做非常快速的切换，让你感觉像是同时执行多个线程。且切换具有不确定性。
    此外，此时的线程也都是串行程序，不涉及并行算法，不涉及并行计算，本质仍是串行的。
    多核cpu：
    多核的并行处理是真的。
    假设有4个核，不开超线程，那么同时可以执行4个线程，是真正的并行执行。
    由于并行执行，也引入了一些新的单核不存在的问题，比如负载均衡、优先级调度等等。这就是真的并行计算的范畴了。
    所以，论并行“能力”，多核是要强的，而单核的单线程能力往往要比多核里面的核要强。
    但“能力”是一回事，真正用起来后的“性能”是另一回事。未经并行设计的程序/软件跑起来很难真正用满多核的性能，在多核上跑单线程程序效果肯定不好，此外，即使一个程序线程数很多，如果这些线程无法并发，那依然不行。所以并行计算是机遇与挑战并存的。

    多线程的运行是根据cpu的切换完成的。怎么切换cpu说的算，所以多线程运行有随机性。
    cpu随机性原理：cpu的快速切换造成的，哪个线程获取到了cpu的执行权，哪个线程就执行。

jvm中的多线程

    jvm中至少有两个线程：
    一个是负责自定义代码运行的。这个从main方法开始执行的线程称之为主线程。主线程执行的代码都在main方法中。
    一个是负责垃圾回收的。当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。 
    至于某一时刻到底哪个线程在运行，cpu说了算。

    我们来看下面这段代码：

class Demo{
//定义垃圾回收方法
public void finalize(){
System.out.println("demo ok");
}
}
class FinalizeDemo{
public static void main(String[] args){
new Demo();
new Demo();
new Demo();
System.gc();//启动垃圾回收器。垃圾回收线程是后台线程(守护进程)，随着其他线程的结束而自动结束。
System.out.println("Hello Threads");
}
}

    运行结果如下：

    通过实验，会发现每次结果不一定相同，那是因为cpu的随机性切换造成的。而且每一个线程都有自己运行的代码内容。这个称之为线程的任务。

    我们之所以创建一个线程就是为了去运行指定的任务代码。而线程的任务都封装在特定的区域中。
    比如：
    主线程运行的任务都定义在main方法中，这个是jvm定义的。
    垃圾回收线程在收垃圾时都会运行对象自定义的finalize方法。
    Thread类中的run()方法，用于存储自定义线程要运行的代码。

创建线程方式一：继承Thread类

    我们先来看一个单线程的例子。下面一段代码，除了垃圾回收线程之外，只有主线程。所以d1.show执行完之后，才会执行d2.show。

class Demo{
private String name;
Demo(String name){
this.name = name;
}
public void show(){
for(int i = 0; i < 10; i++)
System.out.println(name+"..."+i);
}
}
class ThreadDemo{
public static void main(String[] args){
Demo d1 = new Demo("张三");
Demo d2 = new Demo("麻子");
d1.show();
d2.show();
}
}

    输出为：

    那么，如何开辟一个执行路径呢？
    通过查阅API文档 java.lang.Thread类。该类的描述中有创建线程的两种方式。
    第一种就是继承Thread类。

    步骤：
    1.继承Thread类。
    2.覆盖run方法。
    3.创建子类对象就是创建线程对象。
    4.调用Thread类中的start方法就可以执行线程。并会调用run方法。

class Demo extends Thread{
private String name;
public Demo(String name){
super();//父类构造函数Thread()，会生成gname线程名称""Thread-n""。可以使用父类的getName()方法获取。
this.name = name;
}
//覆盖run方法
public void run(){
for (int x = 1; x <= 40; x++){
System.out.println(Thread.currentThread().getName()+"...."+name+"...."+x);//如果仅仅是getName(),获得的只是当前对象的gname，不一定是当前正在运行的线程的gname。
}
}
/*public void start(){//覆盖了Thread类的start方法后，就不能够启动线程了。这时只有main主线程运行。
//super.start();//但如果有这句，就可以启动线程了。使用Thread类的start方法，即可开启。
this.run();//这里，被覆盖的start()方法只有运行run的能力，没有启动线程的能力。这时就只是普通的对象在调用自己的成员方法而已。
}*/
}
class ThreadDemo{
public static void main(String[] args){//主线程栈->main方法->程序入口
Demo d1 = new Demo("张三");//创建d1线程对象。名称gname被设置为 Thread-0，可以通过调用Thread类的getName()方法获取该名称。
Demo d2 = new Demo("麻子");//创建d2线程对象。名称gname被设置为 Thread-1，子类自定义名称name被设置为 麻子。
d1.start();//start()：两件事：1.开启d1线程栈,2.调用run方法。(主线程开辟的d1、d2线程栈区)
d2.start();//主线程开启d2线程栈。但是当前时刻是否执行该线程该run方法，cpu说了算。

for (int x = 1; x < 40; x++){
System.out.println(Thread.currentThread().getName()+"----"+x);
}
}
}

    程序输出：

    start()开启线程后，都会执行run方法，说明run方法中存储的是线程要运行的代码。所以，记住，自定义线程的任务代码都存储在run方法中。(而主线程的代码存储在main方法中)

    返回当前线程的名称：Thread.currentThread().getName()
　　线程的名称是由：Thread—编号定义的。编号从0开始。

    内存图解：

    调用Thread类start和调用run方法的区别？
    调用Thread类start会开启线程，让开启的线程去执行run方法中的线程任务。
    直接调用run方法，线程并未开启，去执行run方法的只有主线程main。

多线程的五种状态

    被创建：start()
    运行：具备执行资格，同时具备执行权；
    冻结：sleep(time)-sleep(time over),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；
    临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；
    消亡：stop()

多线程示例一：售票示例

    卖票的代码需要被多个线程执行，所以要将这些代码定义在线程任务中。run方法。代码如下：

<span style="font-size:14px;">class SaleTicket extends Thread{
private int tickets = 100;
public void run(){
while(true){
if (tickets > 0){
System.out.println(Thread.currentThread().getName()+"...."+tickets--);
}
}
}
}
class TicketDemo{
public static void main(String[] args){
SaleTicket t1 = new SaleTicket();
SaleTicket t2 = new SaleTicket();
SaleTicket t3 = new SaleTicket();
SaleTicket t4= new SaleTicket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}</span>

    创建四个线程。会创建400张票。不合适，不建议票变成静态的，所以如何共享这100张票。需要将资源和线程分离。
    到api文档中查阅了第二种创建线程的方式，实现Runnable接口。

创建线程方式二：实现Runnable接口

    步骤：

    1.定义一个类实现Runnable。
    2.覆盖Runnable接口中的run方法，将线程要运行的任务代码存储到该方法中。
    3.通过Thread类创建线程对象，并将实现了Runnable接口的对象作为Thread类的构造函数的参数进行传递。
    4.调用Thread类的start方法，开启线程。

    改进了的售票示例的代码如下：

class SaleTicket implements Runnable{
private int tickets = 100;
public void run(){
while(true){
if (tickets > 0){
System.out.println(Thread.currentThread().getName()+"...."+tickets--);
}
}
}
}
class TicketDemo2{
public static void main(String[] args){
//线程任务对象
SaleTicket t = new SaleTicket();

//创建四个线程。通过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接口的好处：
    1.避免了继承Thread类的单继承的局限性。
    2.Runnable接口的出现更符合面向对象，将线程任务单独进行对象的封装。
    3.Runnable接口的出现降低了线程对象和线程任务的耦合性。(解耦)

    综上所述，以后创建线程都是用第二种方式。

解决多线程安全问题：同步--synchronized

    上述售票代码的运行，会出现如下的错误情况：

    产生的原因:
    1.线程任务中有处理到共享的数据。
    2.线程任务中有多条对共享数据的操作。一个线程在操作共享数据的过程中，还没有执行完，其他线程参与了运算，造成了数据的错误。

    解决的思想：
    只要保证多条操作共享数据的代码在某一时间段，被一条线程所执行，在执行期间不允许其他线程参与运算。

    咋保证呢？
    java中提供了一个解决方式：同步代码块。
    格式：
    synchronized(对象) // 任意对象都可以。这个对象就是锁，也称为监视器。
    {
        需要被同步的代码。
    }

    再一次改进后的售票示例代码如下：

class SaleTicket implements Runnable{
private int tickets = 100;
Object obj = new Object();
public void run(){
while(true){
/*在线程任务中，只有操作到共享数据的部分需要使用同步代码块*/
synchronized(obj){//obj->同一个锁
if (tickets > 0){
try{Thread.sleep(10);}catch(InterruptedException e){}//让线程到这里稍微停一下，这样可以看到cup切换线程的过程。
System.out.println(Thread.currentThread().getName()+"...."+tickets--);
}
}
}
}
}
class TicketDemo3{
public static void main(String[] args){
SaleTicket t = new SaleTicket();
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();
}
}

    运行结果就正确了：

    同步在目前情况下保证了一次只能有一个线程在执行。其他线程进不来。(火车上的厕所)。这就是同步的锁机制。

    好处：解决了多线程的安全问题。

    弊端：相对降低性能，因为判断锁需要消耗资源，产生了死锁。

    有可能出现这样一种情况：
    多线程安全问题出现后，加入了同步机制，没有想到，安全问题依旧！咋办？

    这时，肯定是同步出了问题。

    只要遵守了同步的前提，就可以解决。

    同步的前提：
    多个线程在同步中必须使用同一个锁。这才是对多个线程同步。也就是说，必须是多个线程在同一个锁上处理同一个共享数据。

    练习：

    两个储户，到同一个银行存钱，每个人存了3次，一次100元。
    1.描述银行。
    2.描述储户任务。

    分析多线程是否存在安全隐患。
    1.线程任务中是否有共享的数据。
    2.是否有多条操作共享数据的代码。

    发现该程序中是有安全隐患的：

    加上同步以后，问题得以解决：

class Bank{
private int sum;
private Object obj = new Object();
public void add(int n){
synchronized(obj){
sum = sum + n;
System.out.println("sum = "+sum);
}

}
}
class Customer implements Runnable{
private Bank b = new Bank();
public void run(){
for (int x = 0; x < 3; x++){
b.add(100);
}
}
}
class ThreadTest{
public static void main(String[] args){
//1.创建任务对象
Customer c = new Customer();

//2.创建线程对象
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);

//3.开启线程
t1.start();
t2.start();
}
}

    运行结果:

匿名线程对象示例

    实际中创建线程，可以使用匿名对象的方式，代码如下：

class ThreadTest{
public static void main(String[] args)throws InterruptedException{
new Thread(){
public void run(){
for (int x = 1; x <= 50; x++)
System.out.println(Thread.currentThread().getName()+"...x = "+x);
}
}.start();

Runnable r = new Runnable(){
public void run(){
for (int x = 1; x <= 50; x++)
System.out.println(Thread.currentThread().getName()+"y = "+x);
}
};
//new Thread(r).start();
Thread t = new Thread(r);
t.start();
t.join();

for (int x = 1; x <= 50; x++)
System.out.println(Thread.currentThread().getName()+"z = "+x);

//-----------如果错误，错误发生在哪一行---------
class Test implements Runnable{
public void run(Thread t){

}
}
//-->错误在第一行，应该被abstract修饰。
//-->一个类如果实现了接口，但是接口的抽象方法没有全被覆盖，该类应该是抽象类。


//------------------结果是什么？-------------------
new Thread(new Runnable(){
public void run(){
System.out.println("runnable run");
}
}){
public void run(){
System.out.println("subThread run");
}
}.start();
//-->以子类为主。打印:subThread run
}
}

同步函数

    同步函数其实就是在函数上加上了同步关键字进行修饰。

    同步的表现形式有两种：

    1.同步代码块(明锁)

    2.同步函数(this锁)。

    同步函数使用的锁是什么呢？
    函数需要被对象调用，哪个对象不确定，但是都用this来表示。同步函数使用的锁就是this。

class Bank{
private int sum;
public synchronized void add(int n){
sum += n;
try{Thread.sleep(10);}catch(Exception e){}
System.out.println("sum = "+sum);
}
}
class Customer implements Runnable{
private Bank b = new Bank();
public void run(){
for(int x = 0; x < 3; x++){
b.add(100);
}
}
}
class BankDemo{
public static void main(String[] args){
Customer c = new Customer();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}

    如何验证同步函数使用的锁就是this呢？

    验证需求：
    启动两个线程。一个线程负责执行同步代码块(使用明锁)。另一个线程使用同步函数(使用this锁)。两个线程执行的任务是一样的，都是卖票。如果他们没有使用相同的锁，说明他们没有同步，会出现数据错误。

    怎么让一个线程一直在同步代码块中，一个线程在同步函数中呢？可以通过切换的方式。设置flag标记位。

    我们还以卖票示例，实验结果发生错误：

    而如果将同步代码块中的obj锁改成this锁，结果就是正确的，说明此时两个线程是同一个锁。这就验证了同步函数使用的是this锁。正确代码如下：

class SaleTicket implements Runnable{
private int tickets = 100;
//定义一个boolean标记。
boolean flag = true;
Object obj = new Object();
public void run(){
if (flag)
while(true){
synchronized(this){//obj-->this
if (tickets > 0){
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...code..."+tickets--);
}
}
}
else
while(true)
sale();
}
public synchronized void sale(){
if (tickets > 0){
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...func..."+tickets--);
}
}
}
class ThisLockDemo{
public static void main(String[] args) throws InterruptedException{
SaleTicket s = new SaleTicket();
Thread t1 = new Thread(s);
Thread t2 = new Thread(s);
t1.start();
Thread.sleep(10);
s.flag = false;
t2.start();
}
}

    运行结果：

    那如果同步函数被static修饰呢？

    注意：字节码文件进入内存后，除了在方法区中进行分布以外，还在堆中生成了一个自己的对象。比如Demo.class字节码文件对象。每个字节码文件对象在堆内存中都是唯一的。也就是说，类进入内存后就有一个对象，这个对象就是字节码文件对象。后期根据new产生的对象都是类的实例，都是根据那个唯一的字节码文件对象在堆内存中创建的。后面说到有关java的反射技术时，会详细介绍。

    static方法随着类加载，这时不一定有该类的对象。但是一定有一个该类的字节码文件对象。这个对象简单的表示方式就是 类名.class (java.lang.Class类)

    所以，被static修饰的同步函数的锁就是类名.class对象。

class SaleTicket implements Runnable{
private static int tickets = 100;
boolean flag = true;
public void run(){
if (flag)
while(true){
synchronized(SaleTicket.class){
if (tickets > 0){
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...code..."+tickets--);
}
}
}
else
while(true)
sale();
}
public static synchronized void sale(){
if(tickets > 0){
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...func..."+tickets--);
}
}
}
class StaticLockDemo{
public static void main(String[] args) throws InterruptedException{
SaleTicket t = new SaleTicket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
Thread.sleep(10);
t.flag = false;
t2.start();
}
}

    同步函数和同步代码块有什么区别呢？

    同步代码块使用的是任意的对象作为锁。
    同步函数只能使用this作为锁。
    如果说，一个类中只需要一个锁，这时可以考虑同步函数，使用this，写法简单。
    但是，一个类中如果需要多个锁，还有多个类中使用同一个锁，这时只能使用同步代码块。

    建议使用同步代码块。

单例模式的并发访问

    饿汉式。相对于多线程并发，比较安全！因为虽然有共享数据，但是没有对共享数据有多条操作。

class Single{
private static final Single SINGLE_INSTANCE = new Single();
private Single(){}
public static Single getInstance(){
//这里如果有判断语句，注意线程安全。
return SINGLE_INSTANCE;
}
}

    懒汉式。延迟加载模式。在多线程并发访问时，会出现线程安全问题。
    加了同步就可以解决。无论是同步函数，还是同步代码块都行。
    但是，效率低了。怎么解决效率问题呢？
    可以通过对单例对象的双重if判断的形式解决！

class Single1{
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;
}
}
/*单例延迟加载模式，并且多线程安全，解决效率问题。*/
class Single2{
private static final Single s = null;
private Single(){}
public static Single getInstance(){
if (s == null){
lock.lock();
try{
if (s == null)
s = new Single();
}finally{
lock.unlock();
}
}
return s;
}
}
class Demo implements Runnable{
public void run(){
Single.getInstance();
}
}
class ThreadSingleTest{
public static void main(String[] args){

}
}

    面试：

    延迟加载单例模式-->函数上加同步解决线程安全问题-->使用的锁是类名.class，字节码对象，比如Single.class-->双重判断解决线程并发访问的效率问题。

死锁

    场景一：同步嵌套。
    场景二：所有线程全部冻结，wait().
    代码示例：

class SaleTicket implements Runnable{
private int tickets = 100;
boolean flag = true;
Object obj = new Object();
public void run(){
if (flag){
while(true){
synchronized (obj){//obj lock
sale();
}
}
}
else
while(true)
sale();
}
public synchronized void sale(){//this lock
synchronized(obj){
if (tickets > 0){
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...func..."+tickets--);
}
}
}
}
class DeadLockDemo{
public static void main(String[] args)throws InterruptedException{
SaleTicket t = new SaleTicket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
Thread.sleep(10);
t.flag = false;
t2.start();
}
}
/*---------------------------------------------------------*/
class Task implements Runnable{
private boolean flag;
public Task(boolean flag){
this.flag = flag;
}
public void run(){
if (flag){
while (true){
synchronized(MyLock.LOCKA){
System.out.println("if......locka");
synchronized(MyLock.LOCKB){
System.out.println("if......lockb");
}
}
}
}
else{
while(true){
synchronized(MyLock.LOCKB){
System.out.println("else......lockb");
synchronized(MyLock.LOCKA){
System.out.println("else......locka");
}
}
}
}
}
}
class MyLock{
public static final Object LOCKA = new Object();
public static final Object LOCKB = new Object();
}
class DeadLockTest{
public static void main(String[] args){
Task t1 = new Task(true);
Task t2 = new Task(false);
new Thread(t1).start();
new Thread(t2).start();
}
}

多线程间的通信：生产者消费者示例

    现实中，我们经常遇到多个线程都在处理同一个资源，但是处理的任务却不一样。

    这里典型的例子就是生产者消费者问题。

    我们先来看单生产者单消费者问题：

    这里程序会出现还没生产就消费的问题，于是在代码中加了同步得以解决。代码如下：

//描述资源
class Res{
private String name;
private int count = 1;

//提供一个给商品赋值的方法
public synchronized void set(String name){//加了同步之后，不会出现还没生产就消费的情况了。
this.name = name + "--" + count;
count++;
System.out.println(Thread.currentThread().getName()+"....生产者...."+this.name);
}

//提供一个获取商品的方法
public synchronized void get(){
System.out.println(Thread.currentThread().getName()+"......消费者......"+this.name);
}
}

//生产者
class Producer implements Runnable{
private Res r;
Producer(Res r){
this.r = r;
}
public void run(){
while(true)
r.set("面包");
}
}

//消费者
class Consumer implements Runnable{
private Res r;
Consumer(Res r){
this.r = r;
}
public void run(){
while(true)
r.get();
}
}

class ProducerConsumerDemo{
public static void main(String[] args){
//创建资源
Res r = new Res();

//创建两个任务
Producer pro = new Producer(r);
Consumer con = new Consumer(r);

//创建线程
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);

//开启线程
t1.start();
t2.start();
}
}

    但是出现了连续的生产没有消费的情况，和需求生产一个就消费一个的情况不符。

    如何实现生产一个就消费一个呢？

等待唤醒机制

    Object监视器方法：
    wait():该方法可以让线程处于冻结状态，并将线程临时存储到线程池中。
    notify():唤醒指定线程池中的任意一个线程。（具体唤醒哪个线程是随机的，允许空唤醒）
    notifyAll():唤醒指定线程池中的所有线程。

    注意：只要使用等待唤醒机制，都应该使用循环判断。

class Res{
private String name;
private int count = 1;
private boolean flag;//定义标记(java中默认值是false)

//提供了给商品赋值的方法。(该同步函数用的锁或者说监视器是this)
public synchronized void set(String name){
if (flag)//判断标记为true，执行wait等待；标记为false，就生产。
try{this.wait();}catch(InterruptedException e){}
this.name = name + "--" + count;
count++;
System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
flag = true;//生产完毕，将标记改为true。
this.notify();//唤醒消费者。
}

//提供一个获取商品的方法。
public synchronized void get(){
if (!flag)
try{this.wait();}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+".....消费者....."+this.name);
flag = false;//将标记改为false。
this.notify();//唤醒生产者。
}
}
class Producer implements Runnable{
private Res s;
Producer(Res s){
this.s = s;
}
public void run(){
while(true)
s.set("面包");
}
}
class Consumer implements Runnable{
private Res s;
Consumer(Res s){
this.s = s;
}
public void run(){
while(true)
s.get();
}
}
class ProducerConsumerDemo2{
public static void main(String[] args){
Res r = new Res();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
t1.start();
t2.start();
}
}

    使用了等待唤醒机制后，单生产者单消费者问题得以解决。运行结果如下 ：

    wait()、notify()、notifyAll()方法必须使用在同步代码块或者同步函数中，因为它们是用来操作同一同步锁上的线程的状态的(即操作同一个监视器对象上线程状态的一组方法)。必须要明确到底操作的是哪个锁上的线程。在使用这些方法时，必须标识它们所属于的锁。标识方式就是锁对象.wait();锁对象.notify(); 锁对象.notifyAll();相同锁的notify()，可以获取相同锁的wait()。

    wait(),notify(),notifyAll()用来操作线程为什么定义在了Object类中？
    1.这些方法存在于同步(synchronized)中。
    2.使用这些方法时必须要标识所属的同步的锁。
    3.锁可以是任意对象，所以任意对象调用的方法一定定义在Object类中。
    其实这些方法是监视器方法，监视器就是锁，锁可以是任意对象，任意对象调用的方式一定定义在Object中。

    备注：
    synchronized 同步函数或同步代码块 可持任意对象作为同步锁 同一锁对象 同一对象监视器 同一组监视器方法 同一线程池 同一等待集 自动释放锁的功能
    同一锁对象所对应的wait,notify,notifyAll监视器方法操作该锁对象上的若干线程
    使用wait,notify,notifyAll监视器方法必须标识所属的同步锁对象，必须用在synchronized中
    wait释放cpu执行权,释放锁。
    sleep释放cpu执行权,不释放锁。

多生产者多消费者问题

    接下来，我们来看多生产多消费的例子。

    如果我们仅仅是多开一对线程，代码会出现以下两个问题：

    问题1：重复生产、重复消费。
    原因：经过复杂(冻结、临时阻塞、运行)的分析，发现被唤醒的线程没有判断标记就开始工作(生产or消费)了。导致了重复的生产和消费的发生。因为使用的if判断标记，所以从wait处唤醒后直接就向下执行代码。
    解决：被唤醒的线程必须判断标记。使用while循环搞定。

    问题2：死锁了。所有的线程都处于冻结状态。
    原因：本方线程在唤醒时，又一次唤醒了本方线程。而本方线程循环判断标记，又继续wait，而导致所有的线程都wait了。
    解决：希望本方如果唤醒了对方线程，就可以解决了。可以使用notifyAll()方法。

    疑问：那不是全唤醒了吗？
    回答：是的。既有本方，又有对方。但是本方醒后，会判断标记继续wait。这样对方就有线程可以执行了。

    代码如下：

class Res{
private String name;
private int count = 1;
private boolean flag;
public synchronized void set(String name){
while(flag)
try{this.wait();}catch(InterruptedException e){}//每次醒来都应该再次判断标记。所以用while，安全。
this.name = name + "--" + count;
count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
this.notifyAll();//唤醒所有等待线程(包括本方线程)
}
public synchronized void get(){
while(!flag)
try{this.wait();}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+".....消费者....."+this.name);
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable{
private Res s;
Producer(Res s){
this.s = s;
}
public void run(){
while(true)
s.set("面包");
}
}
class Consumer implements Runnable{
private Res s;
Consumer(Res s){
this.s = s;
}
public void run(){
while(true)
s.get();
}
}
class ProducerConsumerDemo3{
public static void main(String[] args){
Res r = new Res();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t0 = new Thread(pro);
Thread t1= new Thread(pro);
Thread t2 = new Thread(con);
Thread t3 = new Thread(con);
t0.start();
t1.start();
t2.start();
t3.start();
}
}

    该程序已经实现了多生产多消费。但是有些小问题，效率有点低。因为notifyAll也唤醒了本方，做了不必要的标记判断。而且唤醒了对方全部，也不太合适。如何解决效率问题呢？

JDK1.5: Lock接口、Condition接口

    解决多生产多消费的效率问题。使用了JDK.5 java.util.concurrent.locks包中的对象。

    Lock接口：它的出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成显示锁操作。同时更为灵活，可以一个锁上加上多组监视器。

    lock()：获取锁。
    unlock()：释放锁，通常需要定义到finally代码块中。

    同步代码块或者同步函数的锁操作是隐式的。
    JDK1.5 Lock接口，按照面向对象的思想，将同步和锁单独封装成了一个对象。并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作。

    Lock接口就是同步的替代。将线程中的同步更换为Lock接口的形式。

    注意：不使用synchronized块结构锁就失去了使用synchronized方法和语句时会出现的锁自动释放功能，需使用finally代码块确保执行unlock释放锁。

    替换完运行失败了。无效的监视器状态异常：IllegalMonitorStateException。这是为什么？
    因为wait没有了同步区域，没有了所属的同步锁。那么就不能够使用绑定在同步锁对象上的监视器方法(wait，notify，notifyAll)。同步升级了。其中锁已经不再是任意对象，而是Lock类型的对象。那么和任意对象(同步锁)绑定的监视器方法(监视该锁上线程的状态的方法)，是不是也升级了，有专门和Lock类型锁绑定的监视器方法呢？答案是有的！

    查阅api：
    Condition接口：它的出现替代了Object中的wait，notify，notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象，可以和任意锁进行组合。

    await()：wait()
    signal()：notify()
    signalAll()：notifyAll()

    Lock替代了synchronized方法和语句的使用，Condition替代了Object监视器方法的使用。

    但是，问题依旧，一样唤醒了本方，效率仍旧低！

    Condition将Object监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意Lock实现组合使用。Lock可以支持多个相关的Condition对象。

    以前监视器方法封装到每一个对象(Object)中。现在将监视器方法封装到了Condition对象中。
    方法名为： await signal signalAll

    那监视器对象Condition如何和Lock绑定呢？
    可以通过Lock接口的newCondition()方法完成。它返回绑定到此Lock实例的新Condition实例。

    JDK1.4：
    监视器方法-->Object同步锁对象。
    监视器与锁绑定，锁也就是监视器，一个锁上只能有一组监视器。
    要想一组监视生产者，一组监视消费者，从而让生产者等待的同时唤醒消费者，那么需要将两个锁嵌套，才可以两组监视器，但是这样容易发生死锁。所以我们使用了while、notifyAll的组合，但是效率偏低。

    JDK1.5：
    监视器方法-->Condition对象-->Lock对象。
    监视器方法封装在Condition对象中，一个Lcok锁对象可以绑定多个监视器对象。
    这样就可以一个监视器对象监视生产者，一个监视器对象监视消费者，生产的await与消费的signal搭配使用，就相当于同一个锁上有了两个线程池。这样就实现了本方只唤醒对方中的一个。

    使用JDK1.5 Lock接口改善效率问题，多生产者多消费者完整示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;

class Res{
private String name;
private int count = 1;
private boolean flag;

private Lock lock = new ReentrantLock();//创建一个锁对象

//private Condition con = lock.newCondition();//通过已有的锁对象获取该锁上的监视器对象，使得监视器和锁绑定。

//通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者。
private Condition producer_con = lock.newCondition();
private Condition consumer_con = lock.newCondition();

public void set(String name){
lock.lock();
try{
while(flag)
try{producer_con.await();}catch(InterruptedException e){}//只要醒了，就判断，应该使用循环判断。
this.name = name +"--"+ count;
count++;
System.out.println(Thread.currentThread().getName()+"...生产者5.0..."+this.name);
flag = true;
//this.notifyAll();
//con.signalAll();
consumer_con.signal();//生产完毕，应该唤醒一个消费者来消费。
}finally{
lock.unlock();
}
}
public void get(){
lock.lock();
try{
while(!flag)
try{consumer_con.await();}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+".....消费者5.0....."+this.name);
flag = false;
//this.notifyAll();
//con.signalAll();
producer_con.signal();//消费完后，应该唤醒一个生产者。
}finally{
lock.unlock();
}
}
}
class Producer implements Runnable{
private Res s;
Producer(Res s){
this.s = s;
}
public void run(){
while(true)
s.set("面包");
}
}
class Consumer implements Runnable{
private Res s;
Consumer(Res s){
this.s = s;
}
public void run(){
while(true)
s.get();
}
}
class NewProducerConsumerDemo{
public static void main(String[] args){
Res r = new Res();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t0 = new Thread(pro);
Thread t1= new Thread(pro);
Thread t2 = new Thread(con);
Thread t3 = new Thread(con);
t0.start();
t1.start();
t2.start();
t3.start();
}
}

    JDK1.5的API文档中，Condition接口示例：

class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull  = lock.newCondition(); 
final Condition notEmpty = lock.newCondition(); 

final Object[] items = new Object[100];
int putptr, takeptr, count;

public void put(Object x) throws InterruptedException {
lock.lock();
try {
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 {
while (count == 0) 
notEmpty.await();
Object x = items[takeptr]; 
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
} 
}

    练习：

    1.搞定妖的问题。
      分析：1.共享数据 2.线程任务中有多条操作共享数据的代码。
      加了同步，问题依旧。看同步的前提！多个线程、同一个锁。将输入输出都加了同步，问题解决

    2.name和sex是私有的。需要在Res类中对外提供访问name和sex的方法。这个可以参照生产者消费者ProducerConsumerDemo.java。已解决。

    3.实现间隔输出，使用等待唤醒机制。ProducerConsumerDemo.java
      一般情况下需要判断条件。

import java.util.concurrent.locks.*;

/*实在找不到合适的锁，就自己定义一个*/
class MyLock{//自定义锁
public static final Object obj = new Object();
}

class Res{
private String name;
private String sex;
private boolean flag;
private Lock lock = new ReentrantLock();
private Condition con = lock.newCondition();
public void set(String name, String sex){
lock.lock();
try{
while(flag)
try{con.await();}catch(InterruptedException e){}
this.name = name;
this.sex = sex;
flag = true;
con.signal();
}finally{
lock.unlock();
}
}
public void get(){
lock.lock();
try{
while(!flag)
try{con.await();}catch(InterruptedException e){}
System.out.println(this.name+"......"+this.sex);
flag = false;
con.signal();
}finally{
lock.unlock();
}
}
}
class Input implements Runnable{
private Res s;
Input(Res s){
this.s = s;
}
public void run(){
int x = 0;
while(true){
if (x == 0)
s.set("张三","男男男男男男");
else
s.set("rose","woman");
x = (x+1)%2;
}
}
}
class Output implements Runnable{
private Res s;
Output(Res s){
this.s = s;
}
public void run(){
while(true)
s.get();
}
}
class Test{
public static void main(String[] args){
Res r = new Res();
Input in = new Input(r);
Output out = new Output(r);
Thread t0 = new Thread(in);
Thread t1 = new Thread(out);
t0.start();
t1.start();
}
}

wait()和sleep()区别

    相同：可以让线程处于冻结状态。
    不同：
    1.wait()： 可以指定时间，也可以不指定。
      sleep()：必须指定时间。
    2.wait()： 释放CPU资源，释放锁。
      sleep()：释放CPU资源，不释放锁。

    同步里面只能有一个线程。但是同步中如果有wait()，会出现多线程情况，但是不用担心数据错误的问题。是因为，在同步中的临时阻塞状态的线程要想运行，必须要持有锁。只有持有锁的那个线程具有执行权。执行完再把锁放掉，其他线程才有资格执行。

    所以记住，在同步之中，假设有n个线程从冻结状态恢复到了临时阻塞状态，即具备了执行资格，此时如果锁没有被任何线程持有，并且CPU切到这n个线程其中的一个上，那么这个线程同时具备执行权和锁。只有拿到锁的这个线程才能运行。 所以即使都醒了，也不怕，因为任意时刻只有一个线程可以持有锁，持有锁的线程才能执行。

    同步中，具备执行资格的活着的线程可以有多个，但是真正具备执行权的运行的线程只有一个。谁持有着锁，谁就运行。

synchronized(obj){
obj.wait();//t0, t1, t2,...,tn争夺执行权，获得执行权的同时获得被t3释放的锁
code...
}
synchronized(obj){
obj.notifyAll();//t3
}//t3释放锁

异常在多线程中的体现

    异常会提示它发生在哪个线程上。

    异常会结束线程任务，也就是说可以结束所在线程。

class Demo implements Runnable{
public void run(){
System.out.println(4/0);
}
}
class ThreadExceptionDemo{
public static void main(String[] args)throws Exception{
new Thread(new Demo()).start();
Thread.sleep(10);
int[] arr = new int[3];
System.out.println(arr[2]);
System.out.println("over");
}
}

    运行结果:

停止线程方式

    方法一：定义循环结束标记(变量)
    原理：让run方法结束。
    线程任务通常都有循环。因为开启线程就是为了执行需要一些时间的代码。不让任务A苦苦等待任务B的完成才执行。
    只要控制住循环，就可以结束run方法，就可以停止线程。

class StopThread implements Runnable{
private boolean flag = true;
public void run(){
while(flag){
System.out.println(Thread.currentThread().getName()+"......");
}
}
public void setFlag(){
this.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 = 1;
for(;;){
if (++num == 50){
st.setFlag();
break;
}
System.out.println(Thread.currentThread().getName()+"............"+num);
}
System.out.println("over");
}
}

    但是，第一种方式会出现死锁的情况，如果线程处于冻结状态，就无法读到定义的标记，也就无法在想要的时刻实现停止线程。如下所示：

class StopThread implements Runnable{
private boolean flag = true;
public synchronized void run(){
while(flag){
try{
wait();//t0  t1
}catch(InterruptedException e){
System.out.println(Thread.currentThread().getName()+"......"+e);
}
System.out.println(Thread.currentThread().getName()+".....++++++");
}
}
public void setFlag(){
this.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 = 1;
for(;;){
if (++num == 50){
st.setFlag();
break;
}
System.out.println(Thread.currentThread().getName()+"............"+num);
}
System.out.println("over");
}
}

    方法二：使用interrupt(中断)方法
    interrupt()：中断线程，强制结束线程的冻结状态，并抛出异常。
    将线程从冻结状态强制恢复到临时阻塞或运行状态，让线程具备cpu的执行资格，但是强制动作会发生InterruptedException异常，记得要处理。

class StopThread implements Runnable{
private boolean flag = true;
public  synchronized void run(){
while(flag){
try{
this.wait();
}catch(InterruptedException e){
System.out.println(Thread.currentThread().getName()+"................"+e.toString());
flag = false;
}
System.out.println(Thread.currentThread().getName()+"......hello");
}
}
}
class StopThreadDemo{
public static void main(String[] args)throws InterruptedException {
StopThread st = new StopThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t2.start();
Thread.sleep(10);
for(int x = 0; x <= 50; x++){
if (x == 40){
t1.interrupt();//强制唤醒线程，并抛出InterruptedException异常。
t2.interrupt();
}
System.out.println(Thread.currentThread().getName()+"......"+x);
}
System.out.println("main over");
}
}

    stop()方法已经过时，不再使用。

守护进程

    守护进程：即后台进程，当所有前台进程结束，后台进程无论是否执行完，随之结束。当正在运行的线程都是守护进程时，jvm退出。
    setDaemon()：该方法必须在启动线程前调用。

    应用：比如一个输入线程，一个输出线程，可以将输出线程置为守护线程。只要没有输入了，输出线程就自动结束。

class StopThread implements Runnable{
private boolean flag = true;
public synchronized void run(){
while(flag){
try{
this.wait();
}catch(InterruptedException e){
System.out.println(Thread.currentThread().getName()+"............"+e.toString());
flag = false;
}
System.out.println(Thread.currentThread().getName()+"......hello");
}
}
}
class StopThreadDemo2{
public static void main(String[ ] args){
StopThread st = new StopThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t2.setDaemon(true);//将t2设置为守护进程。
t2.start();
for(int x = 0; x <= 50; x++){
if (x == 40){
t1.interrupt();
}
System.out.println(Thread.currentThread().getName()+"..."+x);
}
System.out.println(Thread.currentThread().getName()+" over");
}
}

Thread类的一些方法

    join()：等待该线程终止。临时加入一个线程运算时，可以使用join方法。

class Demo implements Runnable{
public void run(){
for (int x = 1; x <= 40; x++)
System.out.println(Thread.currentThread().getName()+"......"+x);
}
}
class JoinDemo{
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线程申请加入进来运行，当前主线程释放执行权和执行资格，处于冻结状态，等待t0线程终止，主线程再醒过来执行。
//执行这句话的当前线程冻结，抛出执行权。(本例也即主线程冻结)

t1.start();

t0.join();
//执行到这句话的主线程释放执行权和执行资格，处于冻结状态。
//临时阻塞的所有线程t0、t1争夺该执行权。
//冻结的主线程等到调用join的t0线程终止才被唤醒，重新获得执行资格抢夺执行权。

for (int x = 1; x <= 40; x++)
System.out.println(Thread.currentThread().getName()+"......"+x);
}
}

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

    setPriority()：设置线程优先级(1-10)，优先级越大，当前线程获取cpu执行权的几率越高。默认优先级：5

    yield()：暂停当前正在执行的线程对象。

    线程组ThreadGroup：也就是一个集合，后面会讲到。操作线程组，也就是同时操作线程组中的所有线程。

class Demo implements Runnable{
public void run(){
for (int x = 1; x <= 40; x++){
System.out.println(Thread.currentThread().toString()+"......"+x);
Thread.yield();//暂停当前正在执行的线程对象，释放执行权。
}
}
}
class PriorityDemo{
public static void main(String[] args)throws InterruptedException{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
//t1.join();//等待该线程终止。
Thread.sleep(10);
t1.setPriority(Thread.MAX_PRIORITY);//最大优先级：10
t2.setPriority(Thread.MIN_PRIORITY);//最小优先级：1
for (int x = 1; x <= 40; x++)
System.out.println(Thread.currentThread().toString()+"......"+x);
}
}

多线程总结

1，进程和线程的概念。
 |--进程：
 |--线程：

2，jvm中的多线程体现。
 |--主线程，垃圾回收线程，自定义线程。以及他们运行的代码的位置。

3，什么时候使用多线程，多线程的好处是什么？创建线程的目的？
 |--当需要多部分代码同时执行的时候，可以使用。

4，创建线程的两种方式。★★★★★
 |--继承Thread
  |--步骤
 |--实现Runnable
  |--步骤
 |--两种方式的区别？

5，线程的5种状态。
 对于执行资格和执行权在状态中的具体特点。
 |--被创建：
 |--运行：
 |--冻结：
 |--临时阻塞：
 |--消亡：

6，线程的安全问题。★★★★★
 |--安全问题的原因：
 |--解决的思想：
 |--解决的体现：synchronized
 |--同步的前提：但是加上同步还出现安全问题，就需要用前提来思考。
 |--同步的两种表现方法和区别：
 |--同步的好处和弊端：
 |--单例的懒汉式。
 |--死锁。

7，线程间的通信。等待/唤醒机制。
 |--概念：多个线程，不同任务，处理同一资源。
 |--等待唤醒机制。使用了锁上的 wait notify notifyAll.  ★★★★★
 |--生产者/消费者的问题。并多生产和多消费的问题。  while判断标记。用notifyAll唤醒对方。 ★★★★★
 |--JDK1.5以后出现了更好的方案，★★★
  Lock接口替代了synchronized 
  Condition接口替代了Object中的监视方法，并将监视器方法封装成了Condition
  和以前不同的是，以前一个锁上只能有一组监视器方法。现在，一个Lock锁上可以多组监视器方法对象。
  可以实现一组负责生产者，一组负责消费者。
 |--wait和sleep的区别。★★★★★

8，停止线程的方式。
 |--原理：
 |--表现：--中断。

9，线程常见的一些方法。
 |--setDaemon()
 |--join();
 |--优先级
 |--yield();
 |--在开发时，可以使用匿名内部类来完成局部的路径开辟。

 

好了，Java多线程的内容就这么多，接下来将介绍Java中常用的一些API。

有任何问题请和我联系，共同进步：[e-mail]

转载请声明出处：http://blog.csdn.net/zhongkelee/article/details/45892177