黑马程序员——【Java基础】——多线程

一、概述

　　（一）进程

　　正在执行中的程序，每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

　　（二）线程

　　进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。只要进程中有一个线程在执行，进程就不会结束。

　　（三）多线程

　　在java虚拟机启动的时候会有一个java.exe的执行程序，也就是一个进程。该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。JVM启动除了执行一个主线程，还有负责垃圾回收机制的线程。这种在一个进程中有多个线程执行的方式，就叫做多线程。

　　（四）多线程创建线程的目的和意义

　　1、创建目的：开启一条执行路径；运行的代码就是执行路径的任务。JVM创建的主线程的任务都定义在了主函数中。run方法中，定义的代码就是线程要运行的任务代码。

　　2、创建的意义：可以让程序产生同时运行效果；可以提高程序执行效率。

二、创建线程的方式

　　创建线程共有两种方式：继承方式和实现方式。

　　（一）“继承Thread类”创建多线程

　　Java API文档的java.lang包中提供了Thread类，通过继承Thread类，然后覆写其run方法来创建线程。

　　1、创建步骤

　　（1）定义类，继承Thread。

　　（2）覆写Thread类中的run方法。

　　（3）调用start方法，启动线程，调用run方法执行线程任务代码。

　　2、多线程run和start的特点

　　为什么要覆盖run方法呢？Thread类用于描述线程，该类定义了一个功能，用于存储要运行的代码，这些运行的代码就存储在run方法中。

　　3、练习：创建两线程，和主线程交替运行。示例代码如下：

//创建线程Test  
class Test extends Thread{
    Test(String name){
         super(name);
    }
    //覆写run方法
    public void run(){
        for(int x=0;x<150;x++)
 9　　　　　　　 System.out.println(Thread.currentThread().getName()+"...run..."+x);
    }
}
class MultiThread{
    public static void main(String[] args){
    new Test("Thread one-------").start();//开启第一个线程
    new Test("Thread two---").start();//开启第二个线程
    //主线程执行的代码
    for(int x=0;x<150;x++)
        System.out.println("Hello World!");
    }
}

 　　说明：上述代码每次运行的结果都不一样。因为多个线程都在获取CPU的执行权，CPU执行到谁谁就运行。更明确一点说，在某一时刻，只能有一个程序在运行（多核除外）。CPU是在做着快速的切换，已达到看上去是同时在运行的效果。 

　　（二）“实现Runnable接口”创建多线程

　　使用Thread类继承方式有一个弊端，即如果该类本来就继承了其他父类，那么就无法通过继承Thread类来创建多线程。这样就有了第二种创建线程的方式：实现Runnable接口，并覆写其中的run方法来创建多线程。

　　1、创建步骤

　　（1）定义类实现Runnable接口。

　　（2）覆盖Runnable接口中的run方法。

　　（3）通过Thread类创建线程对象。

　　（4）将Runnable接口的子类对象作为实参传递给Thread类的构造方法。

　　（5）调用Thread类中start方法启动线程，start方法会自动调用Runnable接口子类的run方法。

　　2、细节问题

　　（1）为什么要将Runnable接口的子类对象传递给Thread类的构造函数？

　　因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法，就必须明确该run方法所属对象。

　　（2）实现Runnable的好处：将线程任务从线程的子类中分离出来，进行单独的封装。避免了Java单继承的局限性。在定义线程时，建议使用实现方式。

　　（三）“实现方式”和“继承方式”的区别

　　1、继承方式：线程代码存放在Thread子类的run方法中。

　　2、实现方式：线程代码存在接口的子类run方法中。

　　（四）线程运行状态结构图

 

 　　运行状态结构图说明：

　　1、被创建：等待启动，调用start启动。

　　2、运行状态：具有执行资格和执行权。

　　3、临时状态（阻塞）：有执行资格，但是没有执行权。

　　4、冻结状态：遇到sleep(time)方法和wait()方法时，失去执行资格和执行权，sleep方法时间到或者调用notify()方法时，获得执行资格，变为临时状态。

　　5、消忙状态：stop（）方法，或者run方法结束。

　　（五）获取线程对象以及名称

　　1、原来的线程都有自己默认的名称，命名方式是Thread-编号，编号从0开始。

　　2、通过对象this.getName()、super(name)，可以获取线程对象的名称。也可以通过Thread.currentThread().getName()标准方式获取线程的名称。说明：① static Thread currentThread()：获取当前线程对象。② getName()：获取线程名称。

　　3、设置线程名称：setName(String name)方法或者构造函数都可以实现。

　　4、局部变量在每一个线程区域中都有独立的一份。

　　（六）练习：售票例子

/* 简单卖票程序：多窗口同时卖票 */
class Ticket implements Runnable//extends Thread{
    private  int tick = 100;
    public void run(){
        while(true){
            if(tick>0)
                System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
        }
    }
}
class TicketDemo{
    public static void main(String[] args){
        Ticket t = new Ticket();//创建Runnable接口子类的实例对象
        //有多个窗口在同时卖票，创建三个线程
        Thread t1 = new Thread(t);// 
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

三、多线程的安全问题

　　（一）多个线程“安全问题”

　　1、问题的原因：当多条线程在操作同一个共享数据时，因为CPU的权限分配而出现一个线程对多条语句只执行一部分，还没有执行完，另外一条线程参与进来执行，导致共享数据的错误。

　　2、解决思路：对操作共享数据的多条语句，只能让一个线程都执行完，而其他线程不能执行。

　　（二）解决方式

　　java对于多线程的安全问题提供了专业的解决方式：为需要操作共享数据的多条语句添加synchronized（同步）修饰符。有两种解决方式：一种是同步代码块，另一种是同步函数。都是利用关键字synchronized来实现。

　　1、同步代码块

　　（1）格式：synchronized(对象){ 需要被同步的代码块 }

　　同步可以解决安全问题的根本原因就在那个对象上。对象如同一把锁，持有锁的线程可以在执行同步代码块，而没有持有锁的线程即使获取CPU执行权，也因为没有获取对象而无法执行同步代码块。

　　（2）同步代码块使用的锁是哪一个呢？任意对象。

　　（3）同步代码块示例：为多线程卖票程序加上同步代码块，代码如下：

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--);// 显示线程名及余票数
                }
            }
        }
    }
}

　　2、同步函数

　　（1）格式：synchronized作为函数的修饰符，添加在函数上，就构成了同步函数。

　　（2）同步函数用的是哪一个锁呢？因为函数需要被对象调用，那么函数都持有一个所属对象引用，即this。所以同步函数使用的锁是this。

　　（3）同步函数示例

public synchronized void add(int num){
    sun = sum + num;
    try{
        Thread.sleep(10);
        }catch(InterruptedException e){
        }
        System.out.println(“sum = ”+ sum);
}

　　3、静态同步函数

　　（1）格式：同步函数被static修饰后，就构成了静态同步函数。

　　（2）静态同步函数使用的锁是什么呢？Class对象。

　　说明：因为静态在进内存时，内存中没有本类对象，但一定有该类对应的字节码文件对象，因此，静态同步函数使用的锁是该函数所属字节码文件对象，即 类名.class，该对象的类型是Class，可以用getClass()方法获取，也可以用 类名.class获取。

　　（3）静态同步函数代码示例：

class StaticSynchDemo implements Runnable{
    private static int num = 100;
    public void run(){ System.out.println(“num = ”+ num); };
    public static synchronized void show()    {
        if(num>0) {
            try{
                Thread.sleep(10);
               }catch(InterruptedException e){ }
 9             System.out.println(Thread.currentThread().getName()+".....function...."+num--);
        }
    }
}

　　（三）同步的前提和利弊

　　1、同步的前提

　　（1）必须要有两个或者两个以上的线程。

　　（2）必须是多个线程使用同一个锁。

　　（3）必须保证同步中，只能有一个线程在运行

　　2、同步的利弊

　　利：解决了多线的安全问题。

　　弊：多个线程需要判断锁，较为消耗资源。

　　（四）如何寻找多线程中的安全问题

　　（1）明确哪些代码是多线程运行代码。

　　（2）明确共享数据。

　　（3）明确多线程运行代码中，哪些语句是操作共享数据的。

四、死锁

　　（一）死锁：常见情景之一是“同步的嵌套”。

　　（二）“同步嵌套”出现的死锁示例：

/* 写一个死锁程序 */
class DeadLock implements Runnable {
    private boolean flag;
    DeadLock(boolean flag) {
        this.flag = flag;
    }
    public void run() {
        if (flag){
            while (true)
                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)
                synchronized (MyLock.lockb) {
                    System.out.println(Thread.currentThread().getName()+ "..else  lockb....");
                    synchronized (MyLock.locka) {
                        System.out.println(Thread.currentThread().getName()+ "..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) {
        DeadLock a = new DeadLock(true);
        DeadLock b = new DeadLock(false);

        Thread t1 = new Thread(a);
        Thread t2 = new Thread(b);
        t1.start();
        t2.start();
    }
}

五、线程间通信

　　（一）线程间通信

　　多个线程在操作同一个资源，但是操作的动作不同。

　　（二）等待唤醒机制

　　1、涉及的方法

　　（1）wait(): 让线程处于冻结状态，被wait的线程会被存储到线程池中。

　　（2）notify():唤醒线程池中一个线程(任意)。

　　（3）notifyAll():唤醒线程池中的所有线程。

　　2、为什么这些方法都必须定义在同步中？

　　因为这些方法是用于操作线程状态的方法，必须要明确到底操作的是哪个锁上的线程。

　　3、为什么操作线程的方法wait、notify、notifyAll定义在了Object类中？

　　因为这些方法是监视器的方法。监视器其实就是锁，锁可以是任意的对象，任意的对象调用的方式一定定义在Object类中。

　　4、wait 和 sleep 区别？

　　（1）wait可以指定时间也可以不指定；而sleep必须指定时间。

　　（2）在同步中时，各自对CPU的执行权和锁的处理不同：① wait释放执行权，释放锁。② sleep释放执行权，不释放锁。

　　5、为什么要定义notifyAll ?

　　因为在需要唤醒对方线程时。如果只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

* 练习：多线程通信示例（生产者——消费者）
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(InterruptedException e){}        
        this.name = name + count;
        count++;
        System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
        flag = true;
        notifyAll();
    }

    public synchronized void out(){
        while(!flag)
            try{this.wait();}catch(InterruptedException e){}
        System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
        flag = false;
        notifyAll();
    }
}

class Producer implements Runnable{
    private Resource r;
    Producer(Resource r){
        this.r = r;
    }
    public void run(){
        while(true){
            r.set("烤鸭");
        }
    }
}

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

class  ProducerConsumerDemo{
    public static void main(String[] args){
        Resource r = new Resource();
        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新特性

　　1、jdk1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作。

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

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

　　4、接口Lock上的一些方法

　　（1）lock()：获取锁。

　　（2）unlock()：释放锁，通常需要定义finally代码块中。

　　5、接口Condition上的一些方法

　　（1）await()：使当前线程在接到信号或被中断之前一直处于等待状态。

　　（2）signal()：唤醒一个等待线程。

　　（3）signalAll()：唤醒所有等待线程。

练习：多生产者多消费者问题（JDK1.5解决办法）
import java.util.concurrent.locks.*;
class Resource2
{
    private String name;
    private int count = 1;
    private boolean flag = false;

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

    //通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者。
    Condition producer_con = lock.newCondition();
    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;
            consumer_con.signal();
        }
        finally
        {
            lock.unlock();
        }
        
    }

    public  void out()
    {
        lock.lock();
        try
        {
            while(!flag)
            try{consumer_con.await();}catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName()+"...消费者.5.0......."+this.name);
            flag = false;
            producer_con.signal();
        }
        finally
        {
            lock.unlock();
        }
        
    }
}

class Producer2 implements Runnable
{
    private Resource r;
    Producer2(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.set("烤鸭");
        }
    }
}

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

class  ProducerConsumerDemo2
{
    public static void main(String[] args) 
    {
        Resource r = new Resource();
        Producer2 pro = new Producer2(r);
        Consumer2 con = new Consumer2(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();
    }
}

六、停止线程

　　（一）停止线程的方式

　　  1、stop方法（已过时）。

　　  2、run方法结束。

　　（二）run()方法结束线程

　　 1、“定义标记方式”结束线程任务

　　 怎么控制线程的任务结束呢? 开启多线程运行，运行代码通常都会有循环结构，只要控制住循环就可以让run方法结束，也就是线程结束。控制循环通常就用“定义标记”来完成。

　　 2、“interrupt()方法”结束线程任务

　　 如果线程处于了冻结状态，无法读取标记，如何结束呢？可以使用Thread对象的interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CPU的执行资格，再通过操作标记，让线程任务结束。但是强制动作会发生InterruptedException，记得要处理

　　（三）线程停止示例

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()+"......++++");
        }
    }
    public void setFlag(){
        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.setDaemon(true);//将该线程标记为守护线程(后台线程), 该方法必须在启动线程前调用。
       t2.start();

        int num = 1;
        for(;;){
            if(++num==50){
                t1.interrupt();
                break;
            }
            System.out.println("main...."+num);
        }
        System.out.println("over");
    }
}

　　（四）守护线程（可理解为：后台线程）

　　void setDaemon(boolean on) ：将该线程标记为守护线程或用户线程，可以理解为后台进程。

　　守护线程的特点：

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

　　2、当正在运行的线程都是守护线程时，Java 虚拟机退出。

　　3、当所有的前台线程执行结束，后台线程无论处于什么状态，都自动结束。

　　（五）线程类的其他方法

　　1、setPriority(int newPriority)方法（用来设置线程的优先级）

　　（1）参数newPriority的取值有：MAX_PRIORITY（最高优先级10）、MIN_PRIORITY（最低优先级）、NORM_PRIORITY（默认优先级5）

　　（2）格式：线程.setPriority(Thread. MAX_PRIORITY)

　　2、join()方法

　　当A线程执行到了b线程的.join()方法时，A线程就会等待，等B线程都执行完，A线程才会执行。（此时B和其他线程交替运行。）join可以用来临时加入线程执行。

　　3、yield()方法

　　可以暂停当前线程，释放执行权，让其他线程执行。

　　4、toString()方法

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

七、面试题

　　（一）试题1：以下代码，如果错误 错误发生在哪一行？　　

class Test implements Runnable{
      public void run(Thread t)
      {

      }
}

 　　分析：错误在第一行，应该被abstract修饰 

　　（二）试题2：以下代码的运行结果是什么？深入分析。 

class ThreadTest{
    public static void main(String[] args){
        new Thread(new Runnable(){
            public void run(){
                System.out.println("runnable run");
            }
        })
        {
            public void run(){
                System.out.println("subThread run");
            }
        }.start();
    }
}

 　　运行结果：subThread run。

　　分析：首先当然是以子类为主，所以先执行new Thread(){……..}子类内容。如果子类方法没有内容，再以任务为主，即运行new Runnable(){public void run(){………}}。如果任务都没有，以Thread自己的run方法为主。