线程&同步

一、线程

1.1 并发与并行

• 并发：指两个或多个时间在同一个时间段内发生。
• 并行：指两个或多个时间在同一时刻发生(同时发生)。

1.2 线程与进程

• 进程：是指一个内存中运行的应用的运行程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
  简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

1.3 线程调度

• 分时调度
  所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
• 抢占式调度
  优先让优先级高的线程使用CPU，如果现成的优先级相同，那么会随机选择一个(线程随机性)，java使用的为抢占式调度

1.4 多线程原理

1.5 多线程内存图解

1.6 Thread类的常用方法

1.6.1 获取线程的名称

获取线程的名称：
1.使用Thread类中的的方法getName()
     String getName() 返回该现成的名称
2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称

线程的名称：
主线程：main
新线程：Thread-0，Thread-1，Thread-2

1.6.2 设置线程的名称：(了解)

1.使用Thread类中的方法setName(名字)
    void setName(String name)
改变线程名称，使之与参数 name 相同。
2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类(Thread)给子线程起一个名字
    Thread(String name) 分配新的 Thread 对象。

1.6.3 sleep

public static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
毫秒数结束之后，线程继续执行

1.7 创建线程方式一

创建多线程程序的第一种方式：创建Thread类的子类
java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

实现步骤：
1.创建一个Thread类的子类
2.在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)
3.创建Thread类的子类对象
4.调用Thread类中的方法start方法，开启新的线程，执行run方法
        void start() 使该线程开始执行；Java虚拟机调用该线程的 run 方法。
        结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程，执行其 run 方法）。
        多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

java程序属于抢占式调度，哪个现成的优先级高，哪个线程优先执行；同一个优先级，随机选择一个执行

1.8 创建线程方式二

创建多线程程序的第二种方式：实现Runnable接口
java.lang.Runnable
        Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
java.lang.Thread类的构造方法
        Thread(Runnable target) 分配新的 Thread 对象。
        Thread (Runnable target，String name) 分配新的 Thread 对象。

实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中爨地Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法

1.9 Thread和Runnable的区别

实现Runnable接口创建多线程程序的好处：
1.避免了单继承的局限性
        一个类只能继承一个类(一个人只能有一个亲爹)，类继承了Thread类就不能继承其他的类
        实现了Runnable接口，还可以继承其他的类，实现其他的接口
2.增强了程序的扩展性，降低了程序的耦合性(解耦)
        实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)
        实现类中，重写了run方法：用来设置线程任务
        创建Thread类对象，调用start方法；用来开启新线程

2.0 匿名内部类方式实现线程的创建

匿名：没有名字
内部类：卸载其他类内部的类

匿名内部类最用：简化代码
把子类继承父类，重写父类的方法，创建子类对象合一步完成
把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成

匿名内部类的最终产物：子类/实现类对象，而这个类没有名字

格式：

new 父类/接口(){
    重写父类/接口中的方法
}；

二、线程安全

2.1 线程安全

模拟电影院卖100张票

模拟票：

public class RunnableImpl implements Runnable {
    // 定义一个多个线程共享的票源
    private int ticket = 100;
    
    // 设置线程任务： 卖票
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                // 提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 票存在，卖票
                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                ticket--;
            }
        }
    }
}

测试类：

public class Demo {
    public static void main(String[] args) {
        Runnable run = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

结果中有一部分这样现象：

线程安全问题产生的原因：

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

2.2 线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制 (synchronized)来解决。

根据案例简述：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码 去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。

那么怎么去使用呢？有三种方式完成同步操作：

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

2.3 同步代码块

• 同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式:

synchronized(同步锁){      
    需要同步操作的代码 
}

同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象 可以是任意类型。
2. 多个线程对象 要使用同一把锁
   注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着 (BLOCKED)。

使用同步代码块解决代码：

public class Ticket implements Runnable {
    private int ticket = 100;

    Object lock = new Object();

    /*执行卖票操作*/
    @Override
    public void run() {
        //每个窗口卖票的操作          
        //窗口 永远开启          
        while (true) {
            synchronized (lock) {
                if (ticket > 0) {//有票 可以卖                 
                    // 出票操作                     
                    // 使用sleep模拟一下出票时间                      
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto‐generated catch block                         
                        e.printStackTrace();
                    }
                    //获取当前线程对象的名字                      
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在卖:" + ticket--);
                }
            }
        }
    }
}

2.4 同步方法

• 同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外 等着。

使用步骤：
1.把访问了共享数据的代码抽取出来，放到一个方法中
2.在方法上添加一个synchronized修饰符

格式：

public synchronized 返回值类型 方法名(参数列表){ 
    可能会产生线程安全问题的代码   
}

同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

使用同步方法代码如下：

public class Ticket implements Runnable{
    private int ticket =100;

    @Override
    public void run() {
        while (true) {
            sellTicket();
        }
    }

    public synchronized void sellTicket() {
        if (ticket > 0) {//有票 可以卖                 
            // 出票操作                     
            // 使用sleep模拟一下出票时间                      
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto‐generated catch block                         
                e.printStackTrace();
            }
            //获取当前线程对象的名字                      
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在卖:" + ticket--);
        }
    }
}

2.5 Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

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

使用步骤：
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

使用如下：

三、线程状态

3.1 线程状态概述

3.2 Timed Waiting（计时等待）

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态

sleep方法的使用：

1. 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协 作关系。
2. 为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程 中会睡眠
3. sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。

小提示：sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就 开始立刻执行。

进入TimeWaiting（计时等待）两种方式：
1.使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态

唤醒方法：
void notify() 唤醒在此对象监视器上等待的单个线程。
void notifyAll() 唤醒在此对象监视器上等待的所有线程

3.3 BLOCKED（锁阻塞）

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

3.4 Waiting（无限等待）

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

Waiting 线程状态图

四、等待唤醒机制

4.1 线程间通信

概念：多个线程在处理同一个资源，但是处理的动作(线程的任务)却不相同。

为什么要处理线程间通信：
多个线程变法执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程直线需要一些协调，以此来帮我们达到多线程共同操作一份数据。

4.2 等待唤醒机制

什么是等待唤醒机制
这是多个线程间的一种协作机制。

wait/notify就是线程间的一种协作机制。

等待唤醒中的方法
等待唤醒机制就是用于解决线程通信的问题的，使用到的3个方法的含义如下：
1.wait：线程不在活动，不再参与调度，进入 wait set 中，因此不会浪费CPU资源，也不会去竞争锁，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也就是通知(notify)在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列中
2.notify：则选取所通知对象的 wait set 中的一个线程释放
3.notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：
哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为他当初中端断的地方是在同步代码块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其他线程的竞争），成功后才能在当初调用wait方法之后的地方恢复执行。

调用wait和notify方法需要注意的细节
1.wait方法与notify方法必须要由同一个锁对象调用。
2.wait方法与notify方法是属于Object类的方法的。
3.wait方法与notify方法必须要在同步代码块或同步函数中使用。

4.3 生产者与消费者问题

等待唤醒机制其实就是经典的”生产者与消费者“问题。

以生产包子消费包子为例，代码如下：
包子资源类：

public class BaoZi {
    // 皮
    String pi;

    // 陷
    String xian;

    // 包子状态，默认false没有包子
    Boolean flag = false;
}

包子铺线程类：

public class BaoZiP extends Thread{
    // 创建一个包子变量
    private BaoZi bz;

    //使用带参数构造方法，为包子赋值
    public BaoZiP(BaoZi bz) {
        this.bz = bz;
    }

    // 设置线程任务，生产包子
    @Override
    public void run() {
        // 必须同时同步技术保证两个线程只有一个在执行
        synchronized (bz){
            // 定义一个变量
            int count = 0;
            // 让包子铺一致生产包子
            while (true) {
                // 对包子的状态进行判断
                if (bz.flag == true){
                    //包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 被唤醒之后执行，包子铺生产包子
                // 交替生产两种包子
                if(count%2 ==0){
                    bz.pi = "薄皮";
                    bz.xian = "三鲜馅";
                }else{
                    bz.pi = "冰皮";
                    bz.xian = "牛肉";
                }
                count++;
                System.out.println("包子铺正在生产:" + bz.pi + bz.xian + "包子");
                //生产包子需要3秒
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 包子铺生产好包子
                // 修改包子状态为true 有
                bz.flag = true;
                //唤醒吃货线程，让吃货线程吃包子
                bz.notify();
                System.out.println("包子铺已经生产好了" + bz.pi +bz.xian+"包子，吃货可以开吃");
            }
        }
    }
}

吃货线程类：

public class ChiHuo extends Thread{
    // 创建一个包子变量
    private BaoZi bz;

    //使用带参数构造方法，为包子赋值
    public ChiHuo(BaoZi bz) {
        this.bz = bz;
    }

    // 设置线程任务，生产包子
    @Override
    public void run() {
        // 使用死循环，让吃货一直吃包子
        while (true) {
            synchronized (bz){
                // 对包子状态进行判断
                if (bz.flag == false){
                    //包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 被唤醒之后执行的代码，吃包子
                System.out.println("吃货正在吃：" + bz.pi + bz.xian + "包子");
                //吃货吃完包子
                // 修改包子的状态为flase 没有
                bz.flag = false;
                // 吃货唤醒包子铺线程，生产包子
                bz.notify();
                System.out.println("吃货把：" +bz.pi+bz.xian+"的包子吃完了");
                System.out.println("__________");
            }
        }
    }
}

测试类：

public class Demo {
    public static void main(String[] args) {
        // 创建包子对象
        BaoZi bz = new BaoZi();

        // 创建包子铺线程，开启生产包子
        new BaoZiP(bz).start();

        //创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();
    }
}

五、线程池

5.1 线程池概念

• 线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

线程池的工作原理：

线程池的三个好处：
1.降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2.提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
3.提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

5.2 线程池的使用

线程池：JDK1.5之后提供的
java.util.concurrent.Executors:线程池的工厂类，用来生成线程池

Executors类中的静态方法：
        static ExecutorService newFixedThreadPool(int nThread) 创建一个可重用固定线程数的线程池
        参数：
        int nThread：创建线程池中包含的线程数量
        返回值：
        ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收( 面向接口编程)

java.util.concurrent.ExecutorService：线程池接口
        用来从线程池中获取线程，调用start方法，执行线程任务
                submit(Runnable task) 提交一个 Runnable 任务用于执行
        关闭/销毁线程池的方法
                void shudown()

线程池的使用步骤：
        1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
        3.调用ExecutorService中的方法submit，传递线程任务(实现类)，开启线程，执行run方法
        4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

ThreadPool类

public class ThreadPool {
    public static void main(String[] args) {
        // 1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        es.submit(new RunnableImpl());
        // 3.调用ExecutorService中的方法submit，传递线程任务(实现类)，开启线程，执行run方法
        es.submit(new RunnableImpl()); // pool-1-thread-1创建了一个新的线程
        // 线程池会一直开启，使用完了线程，会自动把线程归还给线程池，线程可以继续使用
        es.submit(new RunnableImpl()); // pool-1-thread-1创建了一个新的线程
        es.submit(new RunnableImpl()); // pool-1-thread-2创建了一个新的线程
    }
}

RunnableImpl类

// 2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"创建了一个新的线程");
    }
}