Java多线程详解从0到1（超详细）

 1 基础名词理解

1.1线程与进程

        线程：是操作系统能够进行运算调度的最小单位。它被包含在进程当中，是进程中的实际运作单位。

        进程：是程序的基本执行实体。一个进程中至少有一个线程。一个进程中是可以有多个线程的。如QQ，微信那些应用就是一个个进程。

1.2并发与并行

        并发：在同一时刻，有多个指令在单个CPU上交替执行。

        并行：在同一时刻，有多个指令在多个CPU上同时执行。

        在java中写的如new Thread(()->{//do something}).start()；启动的多线程我们不能指定其是并发还是并行。

1.3多线程

• 什么是多线程
  • 拥有多个线程，可以让程序同时做很多件事情。
• 多线程的作用
  • 提高程序效率
• 多线程运用场景
  • 只要你想让多个事情同时运行就需要用到多线程。
  • 如：qq聊天界面，一边发送消息一边接收文件

2 多线程的实现方式

2.1三种线程实现方法的优缺点

        继承Thread类和实现Runnable接口两者实现方法在适用场景也不同。实现Runnable接口的方法更适用与多个线程共享处理一些数据，例如多个线程卖电影票。因为在下面代码中只创建了一个Runnable接口的实现类对象，所以多个线程其实操作的成员变量其实是同一份。无需将想要操作的共享数据用static修饰。

• 继承Tread类的方式进行实现

public class Test {
    public static void main(String[] args) {
        Gifts g1 = new Gifts("小王");//创建线程
        Gifts g2 = new Gifts("小吴");
        g1.start();//开启线程
        g2.start();
    }
}

public class Gifts extends Thread {
     public Gifts(String name){
        super(name);
    }
    @Override
    public void run() {
      System.out.println(getName());//输出线程名
    }
}

• 实现Runnable接口的方式进行实现

public class Test {
    public static void main(String[] args) {
        SellingTickets sellingTickets=new SellingTickets();//创建Runnable实现类
        Thread t1=new Thread(sellingTickets,"窗口一");//传入Runnable实现类,并设置线程名字
        Thread t2=new Thread(sellingTickets,"窗口二");
        t1.start();
        t2.start();
    }

}

public class SellingTickets implements Runnable{
  
    @Override
    public void run() {
        //Thread.currentThread()获取当前正在执行的线程
        System.out.println(Thread.currentThread().getName())//输出当前线程的名字
    }
}

• 利用Callable接口和Future接口方式实现

public class MyCallabe implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        //返回一个0-100的随机整数
        return new Random().nextInt(100);
    }
}



public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建MyCallable的对象（表示多线程要执行的任务）
        MyCallabe mc=new MyCallabe();
        //创建FutureTask的对象（作用管理多线程的结果）
        FutureTask<Integer> futureTask=new FutureTask<>(mc);
        //创建线程对象
        Thread t1=new Thread(futureTask);
        t1.start();
        //获取多线程运行结果
        Integer result = futureTask.get();
        System.out.println(result);
        
    }
 
}

3 多线程常用成员方法

 3.1 方法细节

• currentThread（）和sleep（long time）都是静态方法，可以直接使用类名调用
• sleep(long time)，
  • 哪条线程执行到这个方法就会在此位置停留相应时间，不参与CPU资源的抢夺
• setPriority(int newPriority)；设置线程优先级；
  • 线程优先级默认都为5，main线程默认也为5，优先级范围为1~10.优先级越高越容易抢到CPU执行权。
• setDaemon(boolean on);设置为守护线程
  • 当其他线程结束以后，守护线程也会结束，并不是立马结束，要给CUP反应时间，来通知这个线程你要结束了。
• yield();出让线程。
  • 使线程进入等待状态，把运行机会给相同或优先级别更高的线程，但实际中该线程可再次被线程调度器选中。相当于让出线程的占有权，但让出的时间不能设定。
• join()；插入线程
  • 如在main线程用t1线程调用这个方法，则必须要t1线程执行完毕，main线程才能继续往下执行。此时除main和t1外的线程，都不受影响。

4 锁

4.1锁的使用的场景

因为线程执行时是具有随机性的，并不是把线程中的方法全部跑完才换下一个线程，而是无论线程跑到任何位置都有可能结束，运行下一个线程。此时就会倒是数据安全问题。如下图：

三个线程卖99张票，共同操作ticket这个数据。假如此时已经卖到第99张票，线程一通过ticket<99的判断，进入方法体当中。此时线程以突然停止，线程二进入，此时ticket还是99，所以线程二还是能通过判断语句，此时线程二也停止，线程三进入，也能通过判断语句，则线程三卖出第99张票，线程二继续卖，而ticket已经通过++变为第100张票，则，线程二卖出第100张票，随之线程一卖出第101张票。

扫描二维码关注公众号，回复： 16140932 查看本文章

则我们从结果可以看出这个程序是有问题的，只有99张票，但却卖到了101张票。

我们此时需要做的是在保护ticket数据的安全，在操作这个数据时必须操作完，其他线程才能进操作这段，就是必须从判断到卖出这段代码必须全部结束后才能被其他线程运行。而锁就能做到这个要求，

 4.2 锁的实现方法

• 用synchronized关键字锁住代码块(同步代码块)

//synchronizd的实现代码，卖100张票，
//count是票的数量

Object o=new Object();
@Override
    public void run() {
        while(true){
            synchronized (o) {//锁要放在循环里面，不然循环没结束，其他线程都执行不了这个代码，
                if (count == 0) {//然后就一直是这个线程在卖票
                    break;
                } else {
                    System.out.println(Thread.currentThread().getName()+"卖出了第"+(count--)+"张票");
                }
            }
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

• 用synchronized关键字修饰方法(同步方法)

//同步方法实现代码
public class SellingTickets implements Runnable{
    private int count=1000;
    Object o=new Object();
    //Thread.currentThread()获取当前正在执行的线程
    @Override
    public void run() {
        while(sellingTickets(count)){
            try {//用sleep模拟真实卖票场景
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //同步方法，用synchronized关键字修饰
    public synchronized boolean sellingTickets(int count){
        if (count == 0) {
            return false;
        } else {
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(this.count--)+"张票");
            return true;
        }
    }
}

• lock锁（直接开锁关锁）

//Lock锁实现代码
static Lock lock=new ReentrantLock();
    @Override
    public void run() {
        while(true){
            lock.lock();
                try {
                    if (giftQuantity<10){
                        break;
                    }else {
                        System.out.println(getName() + "送出了第" + (giftQuantity--) + "份礼物");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();//注意无论什么情况，都要确保锁能被关闭，不然其他线程获得不到锁
                }
          
        }
    }

4.3 死锁问题

下面代码说明：

        有分别有两个线程，线程A和线程B。他们一同执行下面的代码，线程A拿到了A锁，线程B拿到了B锁，而线程A想要继续执行下面的代码就要获取B锁，但B锁现在在B线程手中，需要拿到，需要等B线程结束释放B锁，而B线程想要继续执行则需要A锁，需要线程A结束释放A锁。此时两线程互相等对方结束，两线程都执行不下去。就形成了死锁问题。

//死锁代码
public class DeadLockDemo extends Thread{
    public DeadLockDemo(String name){
        super(name);
    }
    static Object lA = new Object();
    static Object lb = new Object();
    @Override
    public void run(){
        while(true){
            if("线程A".equals(getName())){
                synchronized (lA){
                    System.out.println("线程A拿到了A锁，准备拿B锁");
                    synchronized (lb){
                        System.out.println("线程A拿到了B锁，完成了一轮");
                    }
                }
            }else if("线程B".equals(getName())){
                synchronized (lb){
                    System.out.println("线程B拿到了B锁，准备拿A锁");
                    synchronized (lA){
                        System.out.println("线程B拿到了A锁，完成了一轮");
                    }
                }
            }
        }
    }
}

5 等待唤醒机制

5.1举例说明

        有三个角色，食客，厨师，桌子。两个线程食客和厨师。

        厨师线程运行时，判断桌子上有没有饭，如果有则用wait()方法，让厨师线程等待，直至被其他线程唤醒，如果没有，则做饭放在桌子上，唤醒食客线程。

        食客线程运行时如果有食物则吃掉，唤醒厨师线程来做，如果没有食物则用wait()方法让食客线程等待。

5.2普通代码实现 

• 厨师

//角色厨师
public class Cook extends Thread{
    @Override
    public void run() {
        while (true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else{
                    //桌子上没有食物
                    if(Desk.sign==0){
                        try {
                            //让这个线程等待。
                            Desk.lock.wait();//让当前线程与这个锁绑定
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        //桌子上有食物
                        System.out.println("食客在吃第"+Desk.count--+"碗，还能再吃"+Desk.count+"碗");
                        Desk.lock.notifyAll();//唤醒所右与这个锁绑定的线程，也就是厨师和食客，然后两者抢夺cpu，如果还是食客抢到了，则会执行上面的代码，
                        //让食客陷入次陷入等待。

                        Desk.sign=0;//修改桌子上食物的状态
                    }
                }
            }
        }
    }
}

• 食客

//角色食客
public class Foodie extends Thread{

    @Override
    public void run() {
        while (true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else{
                    //桌子上没有食物
                    if(Desk.sign==1){
                        try {
                            //让这个线程等待。
                            Desk.lock.wait();//让当前线程与这个锁绑定
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        //桌子上没有食物
                        System.out.println("厨师在做第"+Desk.count+"碗");
                        Desk.lock.notifyAll();//唤醒所右与这个锁绑定的线程，也就是厨师和食客，然后两者抢夺cpu，如果还是食客抢到了，则会执行上面的代码，
                        //让食客陷入次陷入等待。
                        Desk.sign=1;//修改桌子上食物的状态
                    }
                }
            }
        }
    }
}

•  桌子和测试类

//桌子
public class Desk {
    /**
     *  一共来回多少次
     */
    public static int count = 10;

    /**
     * 标记桌子上有没有食物
     */
    public static int sign = 0;

    /**
     * 给厨师和食客的锁
     */
    public static Lock lock=new ReentrantLock();
}

//测试类
public class TreadDemo {
    public static void main(String[] args) {
        Cook cook=new Cook();
        Foodie foodie = new Foodie();
        cook.start();
        foodie.start();
    }
}

5.3阻塞队列实现

  5.3.1阻塞队列说明

• ArrayBlockingQueue：底层是数组，有界。

• LinkedBlockingQueue：底层是链表，无界，但不是真正的无界，最大值为int的最大值。
• put()方法：当队列内数据满了时，放不进去，会等着，也叫阻塞。
• take()方法：取出第一个数据，取不到时会等着，也叫阻塞。

5.3.2阻塞队列细节说明

        在put()和take()方法内部有使用锁来保护线程安全，不需要我们在方法外再使用锁来保护数据。他们是线程安全的。  

5.3.3阻塞队列实现

//厨师
public class Cook extends Thread{
    public static ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String> queue){
        this.queue=queue;
    }
    @Override
    public void run() {
        while (true){
            try {
                queue.put("面条");
                System.out.println("厨师做了一个面条");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//食客
public class Foodie extends Thread{
    public static ArrayBlockingQueue<String> queue;

    public Foodie(ArrayBlockingQueue<String> queue){
        this.queue=queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                String food = queue.take();
                System.out.println("我吃了"+food);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//测试类
public class TreadDemo {
    public static void main(String[] args) {
        ArrayBlockingQueue arrayBlockingQueue=new ArrayBlockingQueue<String>(1);//参数为阻塞队列的大小为1.
        Cook cook=new Cook(arrayBlockingQueue);
        Foodie foodie = new Foodie(arrayBlockingQueue);
        cook.start();
        foodie.start();
    }
}

6 线程状态

 图中的运行状态在java中是没有定义的，因为这个状态JVM交给了操作系统来执行，不关JVM的事了，所以java没有定义运行这个状态。

下图才是Java中正式定义的六种状态：

7  线程池

7.1 线程池主要核心原理

1. 创建一个池子，池子当中是空的
2. 提交任务时，池子会创建新的线程对象，任务执行完毕，线程会归还给池子，下次再次提交任务时，不需要创建新的线程，直接复用已有的线程即可。
3. 如果提交任务时，池子中没有空闲线程，也无法创建新的线程，队伍就会排队等待。

7.2 线程池的代码实现

7.2.1通过Executors线程池工具类通过调用方法创建不同类型的线程池对象。

//代码实现
     /**
     * 创建一个没有上限的线程池
     */
      ExecutorService executorService = Executors.newCachedThreadPool();
        /**
         * 往线程池中提交任务
         */
        LoopTread loopTread = new LoopTread();
        executorService.submit(loopTread);
        executorService.submit(loopTread);
        executorService.submit(loopTread);
        executorService.submit(loopTread);

    /**
     * 销毁线程池
     * 此方法一般不用，因为线程池一般在项目中不进行销毁，随时会有任务
     */
        executorService.shutdown();



    /**
     * 创建一个有上限的线程池
     * 3代表这个线程最多只能同时有三个线程
     */
    ExecutorService executorService1 = Executors.newFixedThreadPool(3);
    /**
     * 提交任务
     * 提交五个任务，从控制台输出可以看出线程的复用
     */
    executorService1.submit(loopTread);
    executorService1.submit(loopTread);
    executorService1.submit(loopTread);
    executorService1.submit(loopTread);
    executorService1.submit(loopTread);

 一共五个任务，但确只使用了三个线程，这就是线程池里的代码复用。

7.2.2自定义创建线程池（创建ThreadPoolExecutor类）

它最长的构造方法有七个参数。

1. 核心线程数量——在线程池当中无论空闲多久都不会被删除的线程
2. 线程池当中最大的线程数量——线程池当中最大能创建的线程数量
3. 空闲时间（数值）——临时线程（线程池中出核心线程之外的线程）空闲了多久就会被淘汰的时间。
4. 空闲时间（单位）——临时线程空闲了多久就会被淘汰的时间单位，要用枚举类TimeUnit类作为参数
5. 阻塞队列——就是创建一个阻塞队列作为参数传入，就是当线程池当中线程数量已经达到了最大线程数量，允许多少个任务排队获取线程，其余的用参数七那个方案来处理。
6. 创建线程的方式——不是new一个线程，而是传入一个线程工厂（例如：Executors工具类中的defaultThreadFactory方法返回的就是一个线程工厂）
7. 要执行的任务过多时的解决方案——当等待队列中也排满时要怎么处理这些任务(任务拒绝策略)。

//代码实现
   /**
     * 之前用工具类进行创建，有好多参数不能自己设置
     * 咱直接自己手动创建一个线程池，自己设置参数
     * 参数一：核心线程数量                           不能小于0
     * 参数二：最大线程数                             不能小于0，数值大于等于核心线程数量
     * 参数三：空闲临时线程最大存活时间（数值）           不能小于0
     * 参数四：空闲临时线程最大存活时间（单位）            用TimeUnit这个枚举类表示
     * 参数五：任务队列，也就是一个堵塞队列               不能为null
     * 参数六:创建线程的工厂                            不能为null
     * 参数七：任务的拒绝策略                             不能为null
     */
 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
        3,  // 核心线程数量
        6,              //最大线程数
        60,             //空闲临时线程最大存活时间（数值）
        TimeUnit.SECONDS,//空闲临时线程最大存活时间（单位）
        new ArrayBlockingQueue<>(3),//任务队列，也就是一个堵塞队列，也可以使用LinkedBlockingQueue这个阻塞队列
        Executors.defaultThreadFactory(),//用线程池工具类Executors创建线程的工厂
        new ThreadPoolExecutor.AbortPolicy()//任务的拒绝策略中其中一个，丢弃任务并抛出RejectedExecutionException
    );
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    threadPoolExecutor.submit(loopTread);
    }

上面的代码我们设置最大线程数量为6，而阻塞队列可以排三个，说明当同时有超过9个任务需要执行，第10个线程就会执行拒绝策略，我设置的策略为丢弃任务，并抛出异常RejectedExecutionException。下面有结果就可以证明我们的猜测。

 74行恰好是我们放入线程池中第10个任务，所以第74行抛出了RejectedExecutionException异常。

自定义线程在不断的提交任务时有三个临界点：

• 当核心线程满时，再提交队伍就会在阻塞队列中排队
• 当核心线程满了，阻塞队列中也慢了，才会创建临时线程
• 当核心线程满了，阻塞队列满了，临时线程也满了，会触发任务拒绝策略，也就是参数七