多线程

理解程序、进程、线程的概念

程序可以理解为静态的代码
进程可以理解为执行中的程序。
线程可以理解为进程的进一步细分，程序的一条执行路径

什么时候需要多线程？

• 程序需要执行两个或者多个任务
• 程序需要实现一些等待的任务时，如用户操作，文件读写操作，网络操作，搜索等。
• 需要一些后台运行的程序时。

  多线程的优势.

• 减少程序的响应时间；
• 线程切换的花销小；
• 使用多线程可以简化程序的结构，使得程序便于理解和维护；

  如何创建线程（重点）

  文字表述

  创建线程的两种方法：

  继承Thread类

  1) 定义子类继承Thread类。
  2) 子类中重写Thread类中的run方法。
  3) 创建Thread子类对象，即创建了线程对象。
  4) 调用线程对象start方法：启动线程，调用run方法

  实现Runnable接口

  1）定义子类，实现Runnable接口。
  2）子类中重写Runnable接口中的run方法。
  3）通过Thread类含参构造器创建线程对象。
  4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
  5）调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

  代码表示：

继承于Thread类

/**
 * Created by 陶世磊 on 2017/8/20.
 *
 * @Description:
 */

class PrintNum extends Thread{
    public void run(){//子线程执行的代码
        for(int i = 1;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
    public PrintNum(String name){
        super(name);
    }
}
public class TestThread {
    public static void main(String[] args) {
        PrintNum p1 = new PrintNum("线程1");
        PrintNum p2 = new PrintNum("线程2");
        p1.setPriority(Thread.MAX_PRIORITY);//10
        p2.setPriority(Thread.MIN_PRIORITY);//1
        p1.start();
        p2.start();
    }
}

方式二：实现Runnable接口

/**
 * Created by 陶世磊 on 2017/8/20.
 *
 * @Description:
 */

class SubThread implements Runnable{
    public void run(){//子线程执行的代码
        for(int i = 1;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class TestThread{
    public static void main(String[] args){
        SubThread s = new SubThread();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
}

两种方式的对比：联系：class Thread implements Runnable
比较哪个好？实现的方式较好。
①解决了单继承的局限性。②如果多个线程有共享数据的话，建议使用实现方式，同时，共享数据所在的类可以作为Runnable接口的实现类。

线程里的常用方法：

start() run() currentThread() getName()
setName(String name) yield() join() sleep() isAlive()
getPriority() setPriority(int i)； wait() notify() notifyAll()

线程的生命周期

new runnable running block dead
可以通过getState()方法来获取线程当前的状态

新生状态

在程序中用构造方法（new操作符）创建一个新线程时，如new Thread(r)，该线程就是创建状态，此时它已经有了相应的内存空间和其它资源，但是还没有开始执行。

就绪状态

新建线程对象后，调用该线程的 start()方法就可以启动线程。当线程启动时，线程进入就绪状态（runnable）。由于还没有分配CPU，线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。当系统挑选一个等待执行的Thread对象后，它就会从等待执行状态进入执行状态。系统挑选的动作称之为“CPU调度”。一旦获得CPU线程就进入运行状态并自动调用自己的run方法。

运行状态

当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的 run()方法。 run()方法定义了该线程的操作和功能。运行状态中的线程执行自己的run方法中代码。直到调用其他方法或者发生阻塞而终止。

阻塞状态

一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入输出操作时，将让出 CPU 并暂时中止自己的执行，进入堵塞状态。在可执行状态下，如果调用 sleep()、 suspend()、 wait()等方法，线程都将进入堵塞状态。堵塞时，线程不能进入排队队列，只有当引起堵塞的原因被消除后，线程转入就绪状态。重新到就绪队列中排队等待，这时被CPU调度选中后会从原来停止的位置开始继续执行。
记住：阻塞被消除后是回到就绪状态，不是运行状态。

死亡状态

线程调用 stop()方法、destory()方法或 run()方法执行结束后，线程即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。不推荐使用stop()方法【会产生异常】 destory()方法【destory是强制终止，不会释放锁】

同步和异步的区别

线程的同步机制（重点）

前提：如果我们创建的多个线程，存在着共享数据，那么就有可能出现线程的安全问题：当其中一个线程操作共享数据时，还未操作完成另外的线程就参与进来，导致对共享数据的操作出现问题。
解决方式：要求一个线程操作共享数据时，只有当其完成操作完成共享数据，其它线程才有机会执行共享数据。

方式一：同步代码块：

synchronized(同步监视器){
//操作共享数据的代码
}

注：
1.同步监视器：俗称锁，任何一个类的对象都可以才充当锁。要想保证线程的安全，必须要求所有的线程共用同一把锁！
2.使用实现Runnable接口的方式创建多线程的话，同步代码块中的锁，可以考虑是this。如果使用继承Thread类的方式，慎用this!
3.共享数据：多个线程需要共同操作的变量，需要明确哪部分是操作共享数据的代码。

方式二：同步方法：将操作共享数据的方法声明为synchronized。

比如：public synchronized void show(){ //操作共享数据的代码}

注：1.对于非静态的方法而言，使用同步的话，默认锁为：this。如果使用在继承的方式实现多线程的话，慎用！
2.对于静态的方法，如果使用同步，默认的锁为：当前类本身。以单例的懒汉式为例。 Class clazz = Singleton.class
总结：释放锁:wait();
不释放锁： sleep() yield() suspend() (过时，可能导致死锁)
死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
死锁是我们在使用同步时，需要避免的问题！

线程的通信：

如下的三个方法必须使用在同步代码块或同步方法中！
wait():当在同步中，执行到此方法，则此线程“等待”，直至其他线程执行notify()的方法，将其唤醒，唤醒后继续其wait()后的代码
notify()/notifyAll():在同步中，执行到此方法，则唤醒其他的某一个或所有的被wait的线程。

例题：
1.两个线程交替打印1-100自然数
2.生产者、消费者的例子

代码实现如下：
生产者消费者的例子：

package com.cuteximi;

/*
 * 生产者/消费者问题
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
 * 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，
 * 如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，
 * 如果店中有产品了再通知消费者来取走产品。

    分析：
    1.是否涉及到多线程的问题？是！生产者、消费者
    2.是否涉及到共享数据？有！考虑线程的安全
    3.此共享数据是谁？即为产品的数量
    4.是否涉及到线程的通信呢？存在这生产者与消费者的通信

 */
class Clerk{
    int product;

    public synchronized void addProduct(){//生产产品
        if(product >= 20){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            product++;
            System.out.println(Thread.currentThread().getName() + ":生产了第" + product + "个产品");
            notifyAll();
        }
    }
    public synchronized void consumeProduct(){//消费产品
        if(product <= 0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName() + ":消费了第" + product + "个产品");
            product--;
            notifyAll();
        }
    }
}

class Producer implements Runnable{//生产者

    Clerk clerk;

    public Producer(Clerk clerk){
        this.clerk = clerk;
    }
    public void run(){
        System.out.println("生产者开始生产产品");
        while(true){
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.addProduct();

        }
    }
}
class Consumer implements Runnable{//消费者
    Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }
    public void run(){
        System.out.println("消费者消费产品");
        while(true){
            try {
                Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}


public class TestThread {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);
        Consumer c1 = new Consumer(clerk);
        Thread t1 = new Thread(p1);//一个生产者的线程
        Thread t3 = new Thread(p1);
        Thread t2 = new Thread(c1);//一个消费者的线程

        t1.setName("生产者1");
        t2.setName("消费者1");
        t3.setName("生产者2");

        t1.start();
        t2.start();
        t3.start();
    }
}

交替打印的例子：

package com.cuteximi;
//线程通信。如下的三个关键字使用的话，都得在同步代码块或同步方法中。
//wait():一旦一个线程执行到wait()，就释放当前的锁。
//notify()/notifyAll():唤醒wait的一个或所有的线程
//使用两个线程打印 1-100. 线程1, 线程2 交替打印

class PrintNum implements Runnable {
    int num = 1;
    Object obj = new Object(); //锁
    public void run() {
        while (true) {
            synchronized (obj) {
                obj.notify();
                if (num <= 100) {
                    try {//延迟
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":"
                            + num);
                    num++;
                } else {
                    break;
                }

                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

public class TestThread {
    public static void main(String[] args) {
        PrintNum p = new PrintNum();
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(p);

        t1.setName("甲");
        t2.setName("乙");

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

start() run()

如果线程直接调用run()方法，这会被当成一个普通的函数来使用，这时，只有一个主线程，
然而start()可以异步的调用run()方法，来实现多线程。

基础很重要！

This blog is under a CC BY-NC-SA 3.0 Unported License
本文链接：http://blog.cuteximi.com/Thread/