Java多线程

1.并发与并行

• 并发：指两个或多个事件在同一时间段内发生
• 并行：指两个或多个事件在同一时刻发生（同时发生）
  

2.线程与进程

• 进程：指一个内存中运行的应用程序，每个进程都有一个独立的运行空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，有多个线程的程序成为多线程程序。
  
  线程调度：
• 分时调度
  所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
• 抢占式调度
  优先让优先级高的线程使用CPU，如果线程的优先级相同，会随机选择一个线程（线程随机性），Java使用抢占式调度

3.创建线程类

Java使用Java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序。

创建多线程方法一

• 定义Thread类的子类，并重写该类的run()方法，该run方法中的内容就是线程需要完成的任务，因此把run()方法称为线程执行体
• 创建Thread子类的实例，即创建线程对象
• 调用线程对象的start()方法启动线程

/*
创建多线程的第一种方式：创建Tread类的子类
1.定义一个类，继承Thread类
2.重写Thread类中的run()方法
3.创建子类的实例
4.调用对象的start()方法启动线程
 */
public class demo01Thread {

    static class MyThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println("run: " + i);
            }
        }
    }

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main: " + i);
        }
    }
}

多线程的原理

我们从以上程序的输出可以发现，程序是一会儿执行主线程，一会执行我们创建的线程，是随机的
两个线程一起抢夺CPU的执行时间，谁抢到了就执行

多线程的内存

每开启一个 线程，都会开辟一个独立的栈空间
每个线程之间独立，互不影响

创建多线程方法二

• 创建一个类，实现Runnable接口
• 实现run()方法
• 创建Runnable接口的实现类对象
  注：因为类没有继承Thread，所以该类的实例没有start()方法
  Thread类 的构造方法允许传入一个Runnable接口的实现对象
  要想开启线程需要用带Runnable参数的构造方法创建一个Thread对象，调用该对象的start()方法

/*
创建多线程的第二种方式：实现Runnable接口
1.定义一个类，继承Thread类
2.重写Thread类中的run()方法
3.创建子类的实例
4.调用对象的start()方法启动线程
 */
public class demo02Thread {

    static class MyThread implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        }
    }

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }
}

实现多线程的两种方法区别

如果一个类继承Threa，则不适合资源共享。但是如果实现了Runnable接口，则容易实现资源共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：

1.适合多个相同的程序代码去共享一个资源
2.可以避免Java中单继承的局限性（继承了Thread类就不能继承别的类了）
3.增加程序的健壮性，实现解耦操作，代码可以被多个先线程共享，代码和线程独立
4.线程池只能放入Runnable或Callable类线程，不能直接放入继承Thread的类

扩充：
在Java中，每次执行程序 至少或启动两个线程，一个是main线程，一个是垃圾收集线程

匿名内部类创建多线程

public class demo03InnerThread {
    public static void main(String[] args) {
    //方式一
        new Thread(){
            @Override
            public void run() {
                for(int i = 0; i < 20; i++)
                 System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        }.start();
//方式二
        Runnable r = new Runnable(){
            @Override
            public void run() {
                for(int i = 0; i < 20; i++)
                    System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        };
        new Thread(r).start();
    }
}

4.线程安全

前言

比如说电影院售票问题，一个售票窗口的时候不会出什么问题，但是多个窗口时就有可能同时出售同一张票，这显然是不应该的

我们来模拟一下三个窗口同时售票的情况

public class demo04ThreadSafe {
    static class RunnableImpl implements Runnable{

        private int ticket = 100;

        @Override
        public void run() {
            while(true){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                    ticket--;
                }

            }
        }
    }

    public static void main(String[] args) {
        RunnableImpl r = new RunnableImpl();
        /*3个线程模拟3个窗口*/
        Thread t0 = new Thread(r);
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

运行结果如下：

我们发现出现了重复卖票的情况，那么出现这种情况的原因是什么呢？
上文中说过，Java采用抢占式调度，谁抢到了CPU的执行时间谁就就执行
在线程0卖完第100张票还没来得及更新票的时候，线程1抢到了执行时间，线程1失去了执行权，线程1也来卖票，此时他认为100还没卖出去，继续卖，这就产生了上述情况。
这在现实生活中是不能够发生的。
那么我们如何避免产生这一类的问题呢？
其实我们只需要保证在一个线程在访问公共资源时，无论其是否失去了CPU的执行权，都让其他的线程无法访问公共资源
接下来就来讲讲如何实现

线程同步

为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制
有3中方式完成同步操作：

1.同步代码块
2.同步方法
3.锁机制

1.同步代码块

/*
解决线程安全问题方法一：使用同步代码块
模式：
synchronized(锁对象){
    可能出现线程安全问题的代码块
}

注意：
    1.通过代码块中的锁对象，可以使用任意的对象
    2.但是必须保证多个线程使用的锁对象是同一个
    3.锁对象的作用：
        把同步代码块锁住，只让一个线程在同步代码块中
 */
public class demo05ThreadSafe2 {
    static class RunnableImpl implements Runnable{

        private int ticket = 100;
        Object obj = new Object(); //创建一个锁对象
        @Override
        public void run() {
            while(true){
               synchronized (obj){  //同步代码块
                   if(ticket > 0){
                       System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                       ticket--;
                   }
               }

            }
        }
    }

    public static void main(String[] args) {
        RunnableImpl r = new RunnableImpl();
        Thread t0 = new Thread(r);
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

同步的原理：
使用了一个锁对象
3个线程同时抢夺CPU执行权，谁抢到了谁执行run()方法进行卖票
t0抢到了，执行run()方法，遇到synchronized代码块，会检查是否有锁对象
发现有，就获取到锁对象，进入到同步代码块中
t1抢到了执行权，执行run()方法，遇到synchronized代码块，检查是否有锁对象
发现没有锁对象，就会进入阻塞状态，会一直等到t0线程归还锁对象，等t0执行完归还锁对象后t1才能进入同步代码块
2.同步方法

/*
解决线程安全问题方法一：使用同步方法
1.将访问了共享数据的代码抽取出来放到一个方法中
2.在方法上添加synchronized修饰符
 */
public class demo06ThreadSafe3 {
    static class RunnableImpl implements Runnable{

        private int ticket = 100;
        Object obj = new Object(); //创建一个锁对象
        @Override
        public void run() {
            while(true){
                pay();
            }
        }
        /*
   			定义一个同步方法
   			同步方法的锁对象其实就是执行方法的实现类对象（this）
   			注意：如果同步方法是静态的，那么锁对象是本类的class属性（class文件对象）
   		 */
        public synchronized  void pay(){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                ticket--;
            }
        }
    }

    public static void main(String[] args) {
        RunnableImpl r = new RunnableImpl();
        Thread t0 = new Thread(r);
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

3.Lock锁

java.util.concurrent.locks.lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，功能更强大，更能体现面向对象。

Lock锁将获取锁和释放锁方法化

public void lock(): 加同步锁
public void unlock():释放同步锁

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

/*
解决线程安全问题方法三：使用Lock锁
java.util.concurrent.locks.reentrantLock 实现了lock接口

1.创建reentrantLock类的对象
2.在可能会出现线程安全的位置前调用Lock接口的lock()方法
3.在可能会出现线程安全的位置后面调用Lock接口的unlock()方法
 */
public class demo07ThreadSafe4 {
    static class RunnableImpl implements Runnable{

        private int ticket = 100;
        Lock lock = new ReentrantLock(); //1.创建reentrantLock类的对象
        @Override
        public void run() {
            while (true) {
                lock.lock();//2.在可能会出现线程安全的位置前调用Lock接口的lock()方法
                try{
                    if (ticket > 0) {
                        System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                        ticket--;
                    }
                }finally {
                    lock.unlock();//3.在可能会出现线程安全的位置后面调用Lock接口的unlock()方法
                }


            }
        }
    }

    public static void main(String[] args) {
        RunnableImpl r = new RunnableImpl();
        Thread t0 = new Thread(r);
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

5.线程的状态

等待唤醒机制

1.线程间通信

概念：多个线程在处理同一个资源，但处理的动作不同

比如线程1生产包子，线程2吃包子，包子就是资源，两个线程都是处理包子，但任务不同，两个线程就存在线程通信问题

为什么要处理线程间的通信问题

多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程共同来完成一件任务，并且我们需要他们按照规律执行时，就需要进行协调通信。

如何实现线程间通信
等待唤醒机制

2.等待唤醒机制

什么是等待唤醒机制
即多线程间的协作机制

还是以包子为例：

等待唤醒中的方法：

1.wait() : 线程不再活动，不再参与调度，进入wait set，这时线程的状态为 WAITING。他还要等着别的线程执行notify，在这个对象上等待的线程从wait set中释放出来，进入调度队列
2.notify() : 选取所通知对象wait set 中的一个线程释放
3.notifyAll() : 释放所通知对象wait set 中的所有线程

我们还是以包子铺为例实现一下生产包子和吃包子两个线程间的通信：

public class demo09等待唤醒案例2 {
    /*
    包子类
     */
    static class Baozi{

        String p; //包子皮
        String x;//包子馅
        Boolean status = false;//包子的状态

    }
    /*
    包子铺类
     */
    static class Shop extends Thread{
        private Baozi b; //包子当作锁对象

        public Shop(Baozi b) {
            this.b = b;
        }

        @Override
        public void run() {
            int count = 0;
            while(true){
                synchronized (b){
                    if(b.status){  //此时有包子
                        try {
                            b.wait(); //包子铺进入等待状态

                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    /*被唤醒之后*/
                    if(count % 2 == 0){ //生产薄皮三鲜馅的包子
                        b.p = "薄皮";
                        b.x = "三鲜";
                    }else{  //生产冰皮牛肉大葱馅包子
                        b.p = "冰皮";
                        b.x = "牛肉大葱";
                    }
                    count++;
                    System.out.println("包子铺正在生产" + b.p + b.x + "包子");
                    try {
                        Thread.sleep(3000);//生产包子需要3秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    b.status = true;  //修改包子的状态
                    b.notify(); //唤醒吃货线程
                    System.out.println(b.p + b.x + "包子生产好了！！！");
                }
            }

        }
    }

    /*
    吃货类
     */
    static class Eat extends Thread{
        private Baozi b; //包子当作锁对象

        public Eat(Baozi b) {
            this.b = b;
        }

        @Override
        public void run() {
            while(true){
                synchronized (b){
                    if(!b.status){ //没有包子
                        try {
                            b.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    /*被唤醒之后*/
                    System.out.println("吃货正在吃" +b.p + b.x + "包子");
                    b.status = false; //包子吃完了，修改包子的状态
                    b.notify(); //唤醒包子铺线程
                    System.out.println("吃货已经把" +b.p + b.x + "包子吃完了，包子铺开始生产");
                    System.out.println("--------------------");
                }
            }
        }
    }

    public static void main(String[] args) {
        Baozi b = new Baozi(); //创建包子对象
        new Shop(b).start();//开启包子铺线程
        new Eat(b).start();//开启吃货线程
    }
}

6.线程池

当并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率
那么有没有一种方法可以使线程复用，不必再每次创建线程呢？Java中可以使用线程池达到这样的效果。

线程池实际上就是一个存放线程的集合（ArrayList, LinkedList等）
在JDK1.5以后内置了线程池

Java里面线程池的顶级接口时java.util.concurrent.Executors，该类是线程池的工厂类
Executor类中创建线程池的方法如下：

• public static ExecutorService newFixedThreadPool(int nThread)
  返回线程池对象，可以指定池中线程的数量
• public future<?> submit(Runnable task)
  获取线程池中某一线程对象，并执行

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
线程池的使用
 */
public class demo10ThreadPool {
    public static void main(String[] args) {
        //1.使用线程池工厂类Executors的静态方法newFixedThreadPool生成一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(5);
        //2.创建一个类，实现Runna接口，重写run()方法
        class RunnableImpl implements Runnable{
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "已开始");
            }
        }

        //3.调用 ExecutorService中的submit()方法，传递线程任务，开启线程
        while(true){
            es.submit(new RunnableImpl());  //线程池会一直开启，使用完的线程会自动归还给线程池，可重复使用
        }
    }
}