Java线程入门

创建线程的两种方式:

public class Thread_01_Thread_Start {

    public static void main(String [] args) {

        //Thread()：创建新的Thread对象
        //Thread(String threadname)：创建线程并指定线程实例名
        MyThread myThread1 = new MyThread();//创建线程  Thread()：创建新的Thread对象
        MyThread myThread2 = new MyThread("小王");// 创建线程  Thread(String threadname)：创建线程并指定线程实例名
        // start启动线程，并调用该线程的run方法
        myThread1.start();//线程名称：Thread-0
        myThread2.start();//线程名称：小王
    }
}
//继承Thread类
class MyThread extends Thread {
    MyThread(String name) {
        super(name);
    }
    MyThread() {
        super();
    }
    //复写run方法
    @Override
    public void run() {
        System.out.println("线程名称："+Thread.currentThread().getName());
    //结果为：小王
    }
}

public class Thread_02_Runnable_Start {
    public static void main(String [] args) {
    //Thread(Runnabletarget)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
    //Thread(Runnable target, String name)：创建新的Thread对象
        // 创建线程子类对象
        MyRunnable myRunnable = new MyRunnable ();
        // 创建线程thread对象
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable,"小明");
        //调用线程对象的start方法开启线程
        thread1.start();//线程名称：Thread-0
        thread2.start();//线程名称：小明
    }
}
//继承Runnable类
class MyRunnable implements Runnable {

    MyRunnable() {
        super();
    }
    //复写run方法
    @Override
    public void run() {
        System.out.println("线程名称："+Thread.currentThread().getName());
    }
}

    void start():  启动线程，并执行对象的run()方法
    run():  线程在被调度时执行的操作
    String getName():  返回线程的名称
    void setName(String name):设置该线程名称
    static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable
    static void yield()：线程让步。暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程。若队列中没有同优先级的线程，忽略此方法
    join()：当某个程序执行流中调用其他线程的join() 方法时，调用线程将被阻塞，直到加入join 线程的方法执行完为止。低优先级的线程也可以获得执行
    Static void sleep(long millis)：(指定时间:毫秒)，令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。抛出InterruptedException异常
    stop(): 强制线程生命期结束，不推荐使用
    booleanisAlive()：返回boolean，判断线程是否还活着

• 单个CPU线程在同一时刻只能执行单一Java程序，也就是一个线程多线程
• 单个线程同时只能在单个CPU线程中执行并发
• 线程是操做系统最小的调度单位，进程是资源（好比：内存）分配的最小单位app
• Java中的全部线程在JVM进程中,CPU调度的是进程中的线程编辑器
• Java多线程并非因为CPU线程数为多个才称为多线程，当Java线程数大于CPU线程数，操做系统使用时间片机制，采用线程调度算法，频繁的进行线程切换。

IO阻塞时，线程会释放CPU吗?

当线程处于IO操做时，线程是阻塞的，线程由运行状态切换到等待状态。此时CPU会作上下文切换，以便处理其余程序；当IO操做完成后，CPU会收到一个来自硬盘的中断信号，CPU正在执行的线程所以会被打断，回到ready队列。而先前因I/O而waiting的线程随着I/O的完成也再次回到就绪队列，此时CPU可能会选择他执行。

JAVA中并发和并行的概念

• 并行：指两个或多个事件在同一时刻点发生，CPU同时执行；
• 并发：指两个或多个事件在同一时间段内发生，CPU交替执行；spa
• JAVA线程能够同时在多个核上运行吗?（思考）
• 操做系统是基于线程调度的，在同一时刻，JAVA进程中不一样的线程可能会在不一样的核上并行运行。
• 线程是调度的最小单位，而进程是资源(好比：内存)分配的最小单位。

时间片轮起色制

• 时间片轮转法（Round-Robin，RR）：
• 根据先进先出原则，排成队列（就绪队列），调度时，将CPU分配给队首进程，让其执行一个时间段（称为：时间片），时间片一般为10-100ms数量级，当执行的时间片用完时，会由计时器发出时钟中断请求，调度程序便据此来中止该进程的执行，并将它排到队列末尾，而后再把CPU从新分配给当前队列的队首进程，同理如此往复。
• 时间片大小取决于：系统对响应时间的要求，就绪队列中进程的数目，系统的处理能力

进程调度

    采用此算法的系统，其程序就绪队列每每按进程到达的时间来排序。进程调度程序老是选择就绪队列中的第一个进程，也就是说按照先来先服务原则调度，但一旦进程占用处理机则仅使用一个时间片。在使用一个时间片后，进程尚未完成其运行，它必须释放出处理机给下一个就绪的进程，而被抢占的进程返回到就绪队列的末尾从新排队等待再次运行。

    处理器同一个时间只能处理一个任务。处理器在处理多任务的时候，就要看请求的时间顺序，若是时间一致，就要进行预测。挑到一个任务后，须要若干步骤才能作完，这些步骤中有些须要处理器参与，有些不须要（如磁盘控制器的存储过程）。不须要处理器处理的时候，这部分时间就要分配给其余的进程。原来的进程就要处于等待的时间段上。通过周密分配时间，宏观上就象是多个任务一块儿运行同样，但微观上是有前后的，就是时间片轮换。

实现思想

时间片轮转算法的基本思想是，系统将全部的就绪进程按先来先服务算法的原则，排成一个队列，每次调度时，系统把处理机分配给队列首进程，并让其执行一个时间片。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序根据这个请求中止该进程的运行，将它送到就绪队列的末尾，再把处理机分给就绪队列中新的队列首进程，同时让它也执行一个时间片

Java调度机制

全部的Java虚拟机都有一个线程调度器，用来肯定哪一个时刻运行哪一个线程。主要包含两种：抢占式线程调度器和协做式线程调度器。

• 抢占式线程调度： 每一个线程可能会有本身的优先级，可是优先及并不意味着高优先级的线程必定会被调度，而是由CPU随机的选择，所谓抢占式的线程调度，就是说一个线程在执行本身的任务时，虽然任务尚未执行完，可是CPU会迫使它暂停，让其它线程占有CPU的使用权。
• 协做式线程调度： 每一个线程能够有本身的优先级，但优先级并不意味着高优先级的线程必定会被最早调度，而是由cpu时机选择的，所谓协做式的线程调度，就是说一个线程在执行本身的任务时，不容许被中途打断，必定等当前线程将任务执行完毕后才会释放对cpu的占有，其它线程才能够抢占该cpu。

二者对比：

抢占式线程调度不易发生饥饿现象，不易由于一个线程的问题而影响整个进程的执行，可是其频繁阻塞与调度，会形成系统资源的浪费。协做式的线程调度很容易由于一个线程的问题致使整个进程中其它线程饥饿。

总结:

• Java在调度机制上采用的是抢占式的线程调度机制。
• Java线程在运行的过程当中多个线程之间是协做式的。

多线程意义

Java多线程并不是由于cpu线程数为多个才称为多线程，当Java线程数大于cpu线程数，操作系统使用时间片机制，采用线程调度算法，频繁的进行线程切换。在网络上有一个被认为合理的线程数值计算为

• 一般情况：线程数 = cpu个数 * 核数
• 计算密集型：线程数 = 处理器核心数
• IO密集型：线程数 = n*处理器核心数

多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。程序的执行其实都是在抢CPU的资源，CPU的执行权。可以提高CPU的使用率。

多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。

我们是不敢保证哪一个线程能够在哪个时刻抢到，所以线程的执行有随机性

问题：

一边玩游戏，一边听音乐是同时进行的吗?

不是。因为单CPU在某一个时间点上只能做一件事情。

而我们在玩游戏，或者听音乐的时候，是CPU在做着程序间的高效切换让我们觉得是同时进行的。

开启多个线程：

    开启多个线程是为了同时运行多部分代码。每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。

多线程的优点：

1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2. 提高计算机系统CPU的利用率
3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和
4. 解决了多部分同时运行的问题。

多线程的弊端：

线程太多效率的降低。

其实应用程序的执行都是cpu在做着快速的切换完成的，这个切换是随机的。

什么时候使用多线程

• 当需要多部分代码同时执行的时候，可以使用。
• 程序需要同时执行两个或多个任务。
• 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
• 需要一些后台运行的程序时。

多线程安全问题：

涉及到两个因素：

解决安全问题的原理：

A:最基本的版本，只有一个数据。
//我们在每个线程中都创建了新的资源，而我们要求的时候设置和
//获取线程的资源都应该是同一个，在外界把这个数据创建出来，
//通过构造方法传递给其他类。
public class StudentDemo {
    public static void main(String[] args) {
        // 创建资源
        Student student = new Student();
        // 设置和获取的类
        SetThread st = new SetThread(student);
        GetThread gt = new GetThread(student);
        // 线程类
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);
        // 启动线程
        t1.start();
        t2.start();
    }
}

class Student {
    String name;
    int age;
}

class SetThread implements Runnable {
    private Student student;

    public SetThread(Student student) {
        this.student = student;
    }

    public void run() {
        student.name = "张三";
        student.age = 27;
    }
}

class GetThread implements Runnable {
    private Student student;

    public GetThread(Student student) {
        this.student = student;
    }

    public void run() {
        System.out.println(student.name + "----" + student.age);
    }
}
B:改进版本，给出了不同的数据，并加入了同步机制
/**
 * 我们在每个线程中都创建了新的资源，而我们要求的时候设置和
 * 获取线程的资源都应该是同一个，在外界把这个数据创建出来，
 * 通过构造方法传递给其他类。
 * 问题（1）多数据情况下，加入了循环判断，给出不同的值，这个时候长生了新的问题
 *  A 同一个数据出现多次：cpu只需要多出一点执行权利就能执行多次
 *  B 姓名年龄不匹配：线程运行的随机性
 *  线程安全问题：多线程环境，有共享数据，有多条语句操作共享数据
 *  解决方法  加锁，不同种类的线程都要加锁，而且必须是同一把。
 */
public class StudentDemo {
    public static void main(String[] args) {
        // 创建资源
        Student student = new Student();
        // 设置和获取的类
        SetThread st = new SetThread(student);
        GetThread gt = new GetThread(student);
        // 线程类
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);
        // 启动线程
        t1.start();
        t2.start();
    }
}

class Student {
    String name;
    int age;
}

class SetThread implements Runnable {
    private Student student;

    private int x = 1;

    public SetThread(Student student) {
        this.student = student;
    }

    public void run() {
        while (true) {
            synchronized (student) {
                if (x % 2 == 0) {
                    // 刚到这失去执行权利
                    student.name = "张三";
                    student.age = 27;
                } else {
                    // 刚到这失去执行权利
                    student.name = "李四";
                    student.age = 30;
                }
                x++;
            }
        }
    }
}

class GetThread implements Runnable {
    private Student student;

    public GetThread(Student student) {
        this.student = student;
    }

    public void run() {
        System.out.println(student.name + "----" + student.age);
    }
}
C:等待唤醒机制改进该程序，让数据能够实现依次的出现
wait()
notify()
notifyAll() (多生产多消费)
package com.multithreading;

/**
 * 我们在每个线程中都创建了新的资源，而我们要求的时候设置和
 * 获取线程的资源都应该是同一个，在外界把这个数据创建出来，
 * 通过构造方法传递给其他类。
 * 问题（1）多数据情况下，加入了循环判断，给出不同的值，这个时候长生了新的问题
 *  A 同一个数据出现多次：cpu只需要多出一点执行权利就能执行多次
 *  B 姓名年龄不匹配：线程运行的随机性
 *  线程安全问题：多线程环境，有共享数据，有多条语句操作共享数据
 *  解决方法  加锁，不同种类的线程都要加锁，而且必须是同一把。
 * 问题（2）虽然数据安全了，但是，一次一大片不太好看，怎么一次一个一个输出：
 *          使用java提供的等待唤醒机制
 * 为什么这些方法不定义在Thread类中？
 *      这些方法的调用必须使用锁对象调用，而我们刚才使用的锁对象失任意锁对象。
 *      所以这些方法必须定义到Object中
 */
public class StudentDemo {
    public static void main(String[] args) {
        // 创建资源
        Student student = new Student();
        // 设置和获取的类
        SetThread st = new SetThread(student);
        GetThread gt = new GetThread(student);
        // 线程类
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);
        // 启动线程
        t1.start();

        t2.start();
    }
}

class Student {
    String name;
    int age;
    boolean flag;// 默认无数据，如果为true，说明有数据
}

class SetThread implements Runnable {
    private Student student;
    private int x = 0;

    public SetThread(Student student) {
        this.student = student;
    }

    public void run() {
        while (true) {
            synchronized (student) {
                if (student.flag) {
                    try {
                        student.wait();
                        // T1就等待了，立即释放锁，将来醒过来的时候，是从这里醒过来
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (x % 2 == 0) {
                    // 刚到这失去执行权利
                    student.name = "张三";
                    student.age = 27;
                } else {
                    // 刚到这失去执行权利
                    student.name = "李四";
                    student.age = 30;
                }
                x++;
                // 修改标记
                student.flag = true;
                // 唤醒线程
                student.notify();// 唤醒T2
            }
        }
    }
}

class GetThread implements Runnable {
    private Student student;

    public GetThread(Student student) {
        this.student = student;
    }

    public void run() {
        while (true) {
            synchronized (student) {
                if (!student.flag) {
                    try {
                        student.wait();
                        // T2就等待了，立即释放锁，将来醒过来的时候，是从这里醒过来
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(student.name + "----" + student.age);

                // 修改标记
                student.flag = false;
                // 唤醒线程
                student.notify();// 唤醒T1
            }
        }
    }
}
D:等待唤醒机制的代码优化。把数据及操作都写在了资源类中

/**
 * 我们在每个线程中都创建了新的资源，而我们要求的时候设置和
 * 获取线程的资源都应该是同一个，在外界把这个数据创建出来，
 * 通过构造方法传递给其他类。
 * 问题（1）多数据情况下，加入了循环判断，给出不同的值，这个时候长生了新的问题
 *  A 同一个数据出现多次：cpu只需要多出一点执行权利就能执行多次
 *  B 姓名年龄不匹配：线程运行的随机性
 *  线程安全问题：多线程环境，有共享数据，有多条语句操作共享数据
 *  解决方法  加锁，不同种类的线程都要加锁，而且必须是同一把。
 * 问题（2）虽然数据安全了，但是，一次一大片不太好看，怎么一次一个一个输出：
 *          使用java提供的等待唤醒机制
 * 为什么这些方法不定义在Thread类中？
 *      这些方法的调用必须使用锁对象调用，而我们刚才使用的锁对象失任意锁对象。
 *      所以这些方法必须定义到Object中
 * 最终:
 *  把student的成员变量给私有化。
 *  把设置和获取的操作给封装成功能，并加了同步。
 *  设置或者获取的线程里面只需要调用方法即可。
 */
public class StudentDemo {
    public static void main(String[] args) {
        // 创建资源
        Student student = new Student();
        // 设置和获取的类
        SetThread st = new SetThread(student);
        GetThread gt = new GetThread(student);
        // 线程类
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);
        // 启动线程
        t1.start();
        t2.start();
    }
}

class Student {
    private String name;
    private int age;
    private boolean flag;// 默认无数据，如果为true，说明有数据

    public synchronized void set(String name, int age) {
        // 如果有数据，就等待
        if (this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 设置数据
        this.name = name;
        this.age = age;

        // 修改标记
        this.flag = true;
        this.notify();
    }

    public synchronized void get() {
        // 如果没有数据，就等待
        if (!this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 获取数据
        System.out.println(this.name + "---" + this.age);

        // 修改数据
        this.flag = false;
        this.notify();
    }
}

class SetThread implements Runnable {
    private Student student;
    private int x = 0;

    public SetThread(Student student) {
        this.student = student;
    }

    public void run() {
        while (true) {
            if (x % 2 == 0) {
                // 刚到这失去执行权利
                student.set("张三", 27);
            } else {
                // 刚到这失去执行权利
                student.set("李四", 30);
            }
            x++;
        }
    }
}

class GetThread implements Runnable {
    private Student student;

    public GetThread(Student student) {
        this.student = student;
    }

    public void run() {
        while (true) {
            student.get();
        }
    }
}

线程同步：

多个线程对账本的共享，会造成操作的不完整性，会破坏

public class Synchronized_0 {
    private int shareData = 0; 
    final Object lock = new Object();// 定义了一个充当锁的Object对象
    public static void main(String[] args) {
        Synchronized_0 test = new Synchronized_0();
        Thread1 st1 = test.new Thread1();
        Thread2 st2 = test.new Thread2();
        st1.start();
        st2.start();
    }
    class Thread1 extends Thread {
        @Override
        public void run() {// 对lock对象上锁
            synchronized (lock) {
                while (shareData < 10) {
                    try {
                        Thread.sleep(2000);
                        System.err.println("Thread1：" + shareData);
                        shareData++;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.err.println("Thread1");
            }
}
}
    class Thread2 extends Thread {
        @Override
        public void run() {// 对lock对象上锁
            synchronized (lock) {
                while (shareData < 100) { 
                    System.out.println("Thread2：while-->shareData-->" + shareData);
                    shareData++;
                }
                System.out.println("Thread2：" + shareData);
            }
        }
    }
}
2：两个人争着用一个锁着的方法
public class Synchronized_1{
    public static void main(String args[]){
        Synchronized_1 a=new Synchronized_1();
        Apple c=a.new Apple();
        synchronized_1A z1=a.new synchronized_1A("小李",c);
        synchronized_1A z2=a.new synchronized_1A("小王",c);
        new Thread(z1).start();
        new Thread(z2).start();
    }
    class synchronized_1A implements Runnable{
        String name;
        Apple apple;
        public synchronized_1A(String name ,Apple apple){
            this.name=name;
            this.apple=apple;
        
        }
        public void run() {
            apple.aa(this.name);
        }
    }
    public class Apple{
        public synchronized void aa(String name) {
            for(int i=0;i<5;i++){
                System.out.println(name+"坐在那里吃饭");
            }
        }
    }
}
// 小李坐在那里吃饭
// 小李坐在那里吃饭
// 小李坐在那里吃饭
// 小李坐在那里吃饭
// 小李坐在那里吃饭
// 小王坐在那里吃饭
// 小王坐在那里吃饭
// 小王坐在那里吃饭
// 小王坐在那里吃饭
// 小王坐在那里吃饭

两种使用synchronized同步关键字的方式

1 定义了一个充当锁的Object对象来解决数据共享的问题;
public class GongXiangDuiXiang_02 {
    public static void main(String[] args) {
        Object lock=new Object();//创建一个线程之间竞争使用的对象
        
        for(int k=1;k<=3;k++){
            new Thread111(lock,k).start();
        }
    }
}
class Thread111 extends Thread {
    private Object lock;//同步锁
    private int id;//线程ID
    
    public Thread111(Object lock,int id){//构造方法引入竞争对象.
        this.lock=lock;
        this.id=id;
    }
    public void run() {
        synchronized (lock) {
            for(int i=1;i<=3;i++){
                System.out.println("线程ID"+id+":"+i);
            }
        }
    }
}
2 通过利用类的变量被所有类的实例所共享.在线程类的内部定义一个静态共享资源.
//通过利用类的变量被所有类的实例所共享.在线程类的内部定义一个静态共享资源.
public class GongXiangDuiXiang_01 {
    public static void main(String[] args) {
            for(int i=1;i<=3;i++){
            new Thread11(i).start();
        }
    }
}
class Thread11 extends Thread {
    private int id;//线程ID
    private static Object lock=new Object();//创建一个线程之间竞争使用的对象
    
    public Thread11(int id){//构造方法引入竞争对象.
        this.id=id;
}
    public void run() {
        synchronized (lock) {
            for(int i=1;i<=3;i++){
                System.out.println("线程ID  "+id+"  输出  "+i);
            }
        }
    }
}
线程ID  2  输出  1
线程ID  2  输出  2
线程ID  2  输出  3
线程ID  3  输出  1
线程ID  3  输出  2
线程ID  3  输出  3
线程ID  1  输出  1
线程ID  1  输出  2
线程ID  1  输出  3
3 定义了一个充当锁的Object对象来解决数据共享的问题;
// TODO 定义了一个充当锁的Object对象来解决数据共享的问题;
public class GongXiangDuiXiang {
    private int shareData = 0; 
    final Object lock = new Object();// 定义了一个充当锁的Object对象
    public static void main(String[] args) {
        GongXiangDuiXiang test = new GongXiangDuiXiang();
        Thread1 st1 = test.new Thread1();
        Thread2 st2 = test.new Thread2();
        st1.start();
        st2.start();
    }
    class Thread1 extends Thread {
        @Override
        public void run() {// 对lock对象上锁
            System.err.println("Thread1：");
            synchronized (lock) {
                while (shareData < 10) {
                    System.err.println("Thread1：" + shareData);
                    shareData++;
                }
            }
        }
    }
    class Thread2 extends Thread {
        @Override
        public void run() {// 对lock对象上锁
            System.out.println("Thread2：" );
            synchronized (lock) {
                while (shareData < 30) {
                    System.out.println("Thread2：" + shareData);
                    shareData++;
                }

            }
        }
    }
}

public synchronized void show (String name){ 
    ….
}

同步方法是用的哪个锁呢？

当同步方法被static修饰时，这时的同步用的是哪个锁呢？

无锁 结果是无序的
public class GongXiangFangFa {
    public static void main(String[] args) {
        new Thread1().start();
        new Thread2().start();
    }
}
class Counter{
    public void excute(String threadName){
        for (int i = 0; i < 5; i++) {
            System.out.println(threadName+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Thread1 extends Thread{
    String threadName = "线程1";
    @Override
    public void run() {
        new Counter().excute(threadName);
    }
}
class Thread2 extends Thread{
    String threadName = "线程2";
    @Override
    public void run() {
        new Counter().excute(threadName);
    }
}
有锁 结果是有序的
public class GongXiangFangFa_01 {
    public static void main(String[] args) {
        Counter_1 counter1 = new Counter_1();
        new Thread_1(counter1).start();//每次传过去一个锁的对象
        new Thread_2(counter1).start();
    }
}
class Counter_1{
    public synchronized void excute(String threadName){
        //每一个类实例都对应一把锁，获得调用该方法的的类实例才能运行，
        //方法一旦执行就独占此锁，直到方法返回回来。此方法是所有类实例对象所共享的.
        for (int i = 0; i < 20; i++) {
            System.out.println(threadName+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Thread_1 extends Thread{
    String threadName = "线程1";
    Counter_1 counter;
    Thread_1(Counter_1 counter){
        this.counter=counter;
    }
    @Override
    public void run() {
        counter.excute(threadName);
    }
}
class Thread_2 extends Thread{
    String threadName = "线程2";
    Counter_1 counter;
    Thread_2(Counter_1 counter){
        this.counter = counter;
    }
    @Override
    public void run() {
        counter.excute(threadName);
    }
}
2:
非静态同步操作方法体
public class GongXiangFangFa_02 {
    public static void main(String[] args) {
        Bike bike = new Bike();
        new PersonThread("小林",bike).start();
        new PersonThread("小王",bike).start();
    }
}

class Bike{
    public synchronized void move(String name){非静态方法
        System.out.println(name+"试图骑自行车");
        for (int i = 1; i <= 20; i++) {
            System.out.println(name+":已经运行"+i+"秒");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class PersonThread extends Thread{
    String name;
    Bike bike;
    PersonThread(String name, Bike bike){
        this.name = name;
        this.bike=bike;
    }
    @Override
    public void run() {
        bike.move(name);
    }
}
静态同步操作方法体
    public class GongXiangFangFa_02 {
        public static void main(String[] args) {
            PersonThread03  person1 =new PersonThread03("小林");
            person1.start();
            PersonThread03 person2 =new PersonThread03("小王");
            person2.start();
        }
    }

    class Bike03{
        public static synchronized void move(String name){//静态方法
            for (int i = 1; i <= 3; i++) {
                System.out.println(name+":已经运行"+i+"毫秒");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class PersonThread03 extends Thread{
        String name;
        PersonThread03(String name){
            this.name = name;
        }
        
        @Override
        public void run() {
            Bike03.move(name);//类名直接调用
        }
    }

​​​​​​​

同步代码块和同步方法的区别？

死锁

同步的嵌套
/*
同步的嵌套是死锁常见情景之一。
*/
class Ticket implements Runnable {
    private int num = 100;
    Object obj = new Object();
    boolean flag = true;

    public void run() {
        if (flag) {
            while (true) {
                synchronized (obj) {
                    show();
                }
            }
        } else {
            while (true) {
                this.show();
            }
        }
    }

    public synchronized void show() {
        synchronized (obj) {
            if (num > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread().getName() + ".....sale...." + num--);
            }
        }
    }
}

public class DeadLockDemo_01 {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        // System.out.println("t:"+t);
        Thread t1 = new Thread(t,"线程A");
        Thread t2 = new Thread(t,"线程B");
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
        }
        t.flag = false;
        t2.start();
    }
}
synchronized同步嵌套死锁：
class Test implements Runnable {
    private boolean flag;

    Test(boolean flag) {
        this.flag = flag;
    }

    public void run() {
        if (flag) {
            while (true)
                synchronized (MyLock.locka) {
                    System.out.println(Thread.currentThread().getName() + "..if lock a....");
                    synchronized (MyLock.lockb) {
                        System.out.println(Thread.currentThread().getName() + "..if lock b....");
                    }
                }
        } else {
            while (true)
                synchronized (MyLock.lockb) {
                    System.out.println(Thread.currentThread().getName() + "..else lock b....");
                    synchronized (MyLock.locka) {
                        System.out.println(Thread.currentThread().getName() + "..else lock a....");
                    }
                }
        }
    }
}

class MyLock {
    public static final Object locka = new Object();
    public static final Object lockb = new Object();
}

public class DeadLockDemo_02 {
    public static void main(String[] args) {
        Test a = new Test(true);
        Test b = new Test(false);
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(b);
        t1.start();
        t2.start();
    }
}

线程间通信：

public class WaitNotify {
    // 创建两个线程之间竞争使用的对象
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();
    ShareThread1 s =new ShareThread1();
    public static void main(String[] args) {
        new ShareThread1().start();
        new ShareThread2().start();
    }

    private static class ShareThread1 extends Thread {
        public void run() {
            synchronized (lock1) {
                try {
                    System.out.println("1111111111");
                    Thread.sleep(50);
                    lock1.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("ShareThread1");
                }
            }
        }
    }

    private static class ShareThread2 extends Thread {
        public void run() {
            synchronized (lock2) {
                try {
                    System.out.println("222222222222");
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("ShareThread2");
                    lock1.notify();
                }
            }
        }
    }
}

等待唤醒机制：

注意：

wait和sleep区别：

public class WaitNotify_0 {
    String data="000";
    PrintThread pt = new PrintThread();
    public static void main(String[] args) {
        new WaitNotify_0().pt.start();
    }
    private class CounterThread extends Thread{
        @Override
        public void run() {
            System.out.println("...");
            synchronized (pt) {
                data="999";
                System.out.println("11111111111");
                pt.notify();
            }
        }
    }
    
    private class PrintThread extends Thread{

        @Override
        public void run() {
            synchronized (this) {
                CounterThread ct = new CounterThread();
                ct.start();
                try {
                    this.wait();//等待的时候把钥匙放手了把锁打开了
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(data);
            }
        }
    }
}

class Single{
    private static Single s = null;
    private Single(){}
    public static Single getInstance(){ //锁是谁？字节码文件对象；
        if(s == null){
            synchronized(Single.class){
                if(s == null)
                    s = new Single();
            }
        }
        return s;
    }
}

线程的停止

public class TestThreadCiycle implements Runnable {
    String name;
    boolean live = true;

    public TestThreadCiycle(String name) {
        super();
        this.name = name;
    }

    public void run() {
        int i = 0;
        while (live) {
            System.out.println(name + (i++));
        }
    }

    public void terminate() {
        live = false;
    }

    public static void main(String[] args) {
        TestThreadCiycle ttc = new TestThreadCiycle("线程A： ");
        Thread t1 = new Thread(ttc);// 新生状态
        t1.start();// 就绪状态
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
        ttc.terminate();
        System.out.println("ttc stop!");
    }
}

public void Thread.interrupt() // 中断线程
public boolean Thread.isInterrupted() // 判断是否被中断
public static boolean Thread.interrupted() // 判断是否被中断，并清除当前中断状态
import java.text.SimpleDateFormat;
import java.util.Date;

public class Interrupt {
    public static void main(String[] args) throws InterruptedException {
        Interrupt1 a=    new Interrupt1();
        a.start();
        Thread.sleep(1000);
        a.interrupt();//void interrupt()：中断线程的阻塞状态（而非中断线程）。把中断的状态给清除；
    }
}
class  Interrupt1 extends Thread{
    public void run(){
        while(true){
            Date date = new Date();
            String pattern = "yyyy-MM-dd HH:mm:ss";
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
            String currentTime = sdf.format(date);
            System.out.println("当前时间："+currentTime);
            try {
                Thread.sleep(5000);// void interrupt()：中断线程的阻塞状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }    
        }
    }
}

第一种中断while循环
阻塞状态和while在try，这样中断阻塞时候直接把while循环也中断
    当前时间：2020-09-26 19:34:23
        
import java.text.SimpleDateFormat;
import java.util.Date;

public class Interrupt {
    public static void main(String[] args) throws InterruptedException {
        Interrupt1 a=    new Interrupt1();
        a.start();
        Thread.sleep(1000);
        a.interrupt();//void interrupt()：中断线程的阻塞状态（而非中断线程）。把中断的状态给清除；
    }
}
class  Interrupt1 extends Thread{
    public void run(){
        try {
while(true){
                Date date = new Date();
                String pattern = "yyyy-MM-dd HH:mm:ss";
                SimpleDateFormat sdf = new SimpleDateFormat(pattern);
                String currentTime = sdf.format(date);
                System.out.println("当前时间："+currentTime);

                Thread.sleep(5000);// void interrupt()：中断线程的阻塞状态
            }
        } catch (InterruptedException e) {
                e.printStackTrace();
java.lang.InterruptedException: sleep interrupted
            at java.lang.Thread.sleep(Native Method)
        at com.method.www.Interrupt1.run(Interrupt.java:25)
        }    
    }
}
第二种中断while循环
public class Interrupt_02 {
    public static void main(String[] args) throws InterruptedException {
    Cou a=    new Cou();
    a.start();
    Thread.sleep(9000); 
    //void sleep(long millis)：静态方法，线程1毫秒之后进入阻塞状态，
    //在指定时间（单位为毫秒）到达之后进入就绪状态。 
    a.stopa();
    }
}
class Cou extends Thread{//中断while循环
    boolean flag=true;
    public Cou(){
        super("计数器线程");
    }
    public void stopa(){
        flag=false;
    }
    
    public void run(){
        try {
            int i=1;
            while(flag){
                System.out.println(this.getName()+":"+i);
                i++;
                sleep(3000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread());
    }
}

线程的基本操作-线程中断

public static void sleep(long millis) throws InterruptedException
public void run(){
    while(true){
        if(Thread.currentThread().isInterrupted()){
            System.out.println("Interruted!");
            break;
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            System.out.println("Interruted When Sleep");
            //设置中断状态，抛出异常后会清除中断标记位
            Thread.currentThread().interrupt();
        }
        Thread.yield();
    }
}

setPriority(int newPriority)：更改线程的优先级。

getPriority()：返回线程的优先级。

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

Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。

setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

join

临时加入一个线程的时候可以使用join方法。

当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。A什么时候执行呢？只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。

public class Join {
    String data="000";
    static Join s=new Join();//创建一个对象进行调用,不能用两个,两个
    static PrintThread pt = s.new PrintThread();
    static CounterThread ct = s.new CounterThread();
    public static void main(String[] args) {
        ct.start();
        pt.start();
    }

    private class PrintThread extends Thread{

        @Override
        public void run() {
            System.out.println("000000000");
                try {
                    System.out.println(data);
                    ct.join();//当前线程PrintThread等待加入（join）的CounterThread线程完成，才能继续往下执行。 
                    System.out.println("222222222222");
                    System.out.println(data);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
    }
    private class CounterThread extends Thread{
        @Override
        public void run() {
            System.out.println("1111111111");
            try {
                sleep(1000);
                data="999";
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

synchronized和lock锁的区别

synchronized内置的java关键字,Lock是一个java类
synchronized无法判断获取锁的状态, Lock可以判断是否获取到了锁
synchronized会自动释放锁,Lock必须要手动释放锁!如果不是释放锁,会产生死锁
synchronized 线程1(获得锁,阻塞),线程2(等待); Lock锁就不一定会等待下去
synchronized 可重入锁,不可以中断的,非公平的; Lock锁,可重入的,可以判断锁,非公平(可自己设置);
synchronized 适合锁少量的代码同步问题,Lock 适合锁大量的同步代码

ReentrantLock与synchronized区别及性能差异?

区别

主要相同点：Lock能完成synchronized所实现的所有功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

1.新的ReentrantLock的确实现了和同步块相同的语义功能。而对象锁的获得和释放都可以由编码人员自行掌握。

2.使用新的ReentrantLock，免去了为同步块放置合适的对象锁所要进行的考量。

3.使用新的ReentrantLock，最佳的实践就是结合try/finally块来进行。在try块之前使用lock方法，而在finally中使用unlock方法。

同步的实现当然是采用锁了，java中使用锁的两个基本工具是 synchronized 和 Lock。

synchronized使用很方便。比如，需要对一个方法进行同步，那么只需在方法的签名添加一个synchronized关键字。

未同步的方法

public void test() {}

同步的方法

pubilc synchronized void test() {}

synchronized 也可以用在一个代码块上

public void test() {

  synchronized(obj) {

     System.out.println("===");

  }

}

wait()与notify()与notifyAll()

这三个方法都是Object的方法，并不是线程的方法！

wait():释放占有的对象锁，线程进入等待池，释放cpu,而其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序。而sleep()不同的是，线程调用此方法后，会休眠一段时间，休眠期间，会暂时释放cpu，但并不释放对象锁。也就是说，在休眠期间，其他线程依然无法进入此代码内部。休眠结束，线程重新获得cpu,执行代码。wait()和sleep()最大的不同在于wait()会释放对象锁，而sleep()不会！

notify(): 该方法会唤醒因为调用对象的wait()而等待的线程，其实就是对对象锁的唤醒，从而使得wait()的线程可以有机会获取对象锁。调用notify()后，并不会立即释放锁，而是继续执行当前代码，直到synchronized中的代码全部执行完毕，才会释放对象锁。JVM则会在等待的线程中调度一个线程去获得对象锁，执行代码。需要注意的是，wait()和notify()必须在synchronized代码块中调用。

notifyAll()则是唤醒所有等待的线程。

为了说明这一点，举例如下：

两个线程依次打印"A""B",总共打印10次。

class Consumer1 implements Runnable {
     @Override
     public synchronized void run() {
         int count = 10;
          while (count > 0) {
              synchronized (TestSynchronized.obj) {
              System.out.println("B" + count);
              count --;
              TestSynchronized.obj.notify(); // 主动释放对象锁
              try {
                  TestSynchronized.obj.wait();
              } catch (InterruptedException e) {
                 e.printStackTrace();
              }
            }
        }
     }
}
class Produce1 implements Runnable {
     @Override
     public void run() {
       int count = 10;
       while(count > 0) {
          synchronized (TestSynchronized.obj) {
             //System.out.print("count = " + count);
             System.out.println("A" + count);
             count --;
             TestSynchronized.obj.notify();
             try {
                 TestSynchronized.obj.wait();
             } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
             }
           }
        }
     }
}
//测试类如下：
public class TestSynchronized {
    public static final Object obj = new Object();
    public static void main(String[] args) {
           new Thread( new Produce1()).start();
           new Thread( new Consumer1()).start();
    }
}

这里使用static obj作为锁的对象，当线程Produce启动时（假如Produce首先获得锁，则Consumer会等待），打印“A”后，会先主动释放锁，然后阻塞自己。Consumer获得对象锁，打印“B”，然后释放锁，阻塞自己，那么Produce又会获得锁，然后...一直循环下去，直到count = 0.这样，使用Synchronized和wait()以及notify()就可以达到线程同步的目的。

除了wait()和notify()协作完成线程同步之外，使用Lock也可以完成同样的目的。

     ReentrantLock 与synchronized有相同的并发性和内存语义，还包含了中断锁等候和定时锁等候，意味着线程A如果先获得了对象obj的锁，那么线程B可以在等待指定时间内依然无法获取锁，那么就会自动放弃该锁。

    但是由于synchronized是在JVM层面实现的，因此系统可以监控锁的释放与否，而ReentrantLock使用代码实现的，系统无法自动释放锁，需要在代码中finally子句中显式释放锁lock.unlock();

同样的例子，使用lock 如何实现呢？

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Consumer2 implements Runnable {
     private Lock lock;
     public Consumer2(Lock lock) {
             this.lock = lock;
     }
     public void run() {
            int count = 10;
            while( count > 0 ) {
                 try {
                     lock.lock();
                     count --;
                     System.out.println("B" + count);
                } finally {
                      lock.unlock(); //主动释放锁
                      try {
                           Thread. sleep(91L);
                     } catch (InterruptedException e) {
                           e.printStackTrace();
                     }
                }
           }
     }
}
class Producer2 implements Runnable{
     private Lock lock;
     public Producer2(Lock lock) {
            this.lock = lock;
     }
     public void run() {
            int count = 10;
            while (count > 0) {
                 try {
                     lock.lock();
                     count --;
                     System. out.println("A" + count);
                } finally {
                      lock.unlock();
                      try {
                           Thread.sleep(90L);
                     } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                           e.printStackTrace();
                     }
                }
           }
     }
}
//测试类如下：
public class TestLock {
     public static void main(String[] args) {
           Lock lock = new ReentrantLock();
           Consumer2 consumer = new Consumer2(lock);
           Producer2 producer = new Producer2(lock);
           new Thread(consumer).start();
           new Thread( producer).start();
     }
}

Synchronized与ReentrantLock性能：

在并发量比较小的情况下，使用synchronized是个不错的选择，但是在并发量比较高的情况下，其性能下降很严重，此时ReentrantLock是个不错的方案。

JUC < java.util.concurrent.locks >

JUC是什么？

JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的Collection 实现等

进程与线程的区别：

进程 : 一个运行中的程序的集合; 一个进程往往可以包含多个线程,至少包含一个线程

java默认有几个线程? 两个 main线程 gc线程

线程 : 线程（thread）是操作系统能够进行运算调度的最小单位。

并发与并行的区别：

并发(多线程操作同一个资源,交替执行),CPU一核, 模拟出来多条线程,天下武功,唯快不破,快速交替

并行(多个人一起行走, 同时进行),CPU多核,多个线程同时进行;使用线程池操作

线程有六个状态：

public enum State {
       // 新生
        NEW,
        // 运行
        RUNNABLE,
        // 阻塞
        BLOCKED,
        // 等待
        WAITING,
        //超时等待
        TIMED_WAITING,
        //终止
        TERMINATED;
    }

wait/sleep的区别：

来自不同的类

wait来自object类, sleep来自线程类

关于锁的释放

wait会释放锁, sleep不会释放锁

使用的范围不同

wait必须在同步代码块中

sleep可以在任何地方睡眠

JUC的结构

1，tools（工具类）：又叫信号量三组工具类:

1）CountDownLatch（闭锁） 是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待

2）CyclicBarrier（栅栏） 之所以叫barrier，是因为是一个同步辅助类，允许一组线程互相等待，直到到达某个公共屏障点 ，并且在释放等待线程后可以重用。

3）Semaphore（信号量） 是一个计数信号量，它的本质是一个“共享锁“。信号量维护了一个信号量许可集。线程可以通过调用 acquire()来获取信号量的许可；当信号量中有可用的许可时，线程能获取该许可；否则线程必须等待，直到有可用的许可为止。 线程可以通过release()来释放它所持有的信号量许可。

2，executor(执行者)：

Java里面线程池的顶级接口，但它只是一个执行线程的工具，真正的线程池接口是ExecutorService，里面包含的类有：

1）ScheduledExecutorService 解决那些需要任务重复执行的问题

2）ScheduledThreadPoolExecutor 周期性任务调度的类实现

3，atomic(原子性包)：

JDK提供的一组原子操作类，包含有AtomicBoolean、AtomicInteger、AtomicIntegerArray等原子变量类，他们的实现原理大多是持有它们各自的对应的类型变量value，而且被volatile关键字修饰了。这样来保证每次一个线程要使用它都会拿到最新的值。

4，locks（锁包）：

JDK提供的锁机制，相比synchronized关键字来进行同步锁，功能更加强大，它为锁提供了一个框架，该框架允许更灵活地使用锁包含的实现类有：

1）ReentrantLock 它是独占锁，是指只能被独自占领，即同一个时间点只能被一个线程锁获取到的锁。

2）ReentrantReadWriteLock 它包括子类ReadLock和WriteLock。ReadLock是共享锁，而WriteLock是独占锁。

3）LockSupport 它具备阻塞线程和解除阻塞线程的功能，并且不会引发死锁。

5，collections(集合类)：

主要是提供线程安全的集合， 比如：

1）ArrayList对应的高并发类是CopyOnWriteArrayList，

2）HashSet对应的高并发类是 CopyOnWriteArraySet，

3）HashMap对应的高并发类是ConcurrentHashMap等等

普通的线程代码, 之前都是用的thread或者runnable接口

public class demo01 {
    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.start();
        new Thread(new ThreadDemo2()).start();
    }
}

class ThreadDemo extends Thread{
    @Override
    public void run() {
        System.out.println("普通线程已开启（继承Thread）");
    }
}
class ThreadDemo2 implements Runnable{

    @Override
    public void run() {
        System.out.println("普通线程已开启(实现Runnable接口)");
    }
}
程序运行结果：

程序运行结果：

JUC的volatile 关键字-内存可见性

内存可见性（Memory Visibility）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。

可见性错误是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。

我们可以通过同步来保证对象被安全地发布。除此之外我们也可以使用一种更加轻量级的volatile 变量。

volatile 关键字

Java提供了一种稍弱的同步机制，即volatile 变量，用来确保将变量的更新操作通知到其他线程。可以将volatile 看做一个轻量级的锁，但是又与锁有些不同：

对于多线程，不是一种互斥关系，不能保证变量状态的“原子性操作”

volatile 关键字：当多个线程进行操作共享数据时，可以保证内存中的数据可见。相较于 synchronized 是一种较为轻量级的同步策略。

注意：1. volatile 不具备“互斥性” 2. volatile 不能保证变量的“原子性”

JUC的原子变量-CAS算法

CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问。

CAS 是一种无锁的非阻塞算法的实现。

CAS 包含了3 个操作数：

需要读写的内存值V

进行比较的值A

拟写入的新值B

当且仅当V 的值等于A 时，CAS 通过原子方式用新值B 来更新V 的值，否则不会执行任何操作。

原子变量

类的小工具包，支持在单个变量上解除锁的线程安全编程。事实上，此包中的类可将volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。

类AtomicBoolean、AtomicInteger、AtomicLong 和AtomicReference 的实例各自提供对相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。

AtomicIntegerArray、AtomicLongArray 和AtomicReferenceArray 类进一步扩展了原子操作，对这些类型的数组提供了支持。这些类在为其数组元素提供volatile 访问语义方面也引人注目，这对于普通数组来说是不受支持的。

核心方法：boolean compareAndSet(expectedValue, updateValue)

java.util.concurrent.atomic 包下提供了一些原子操作的常用类:

AtomicBoolean 、AtomicInteger 、AtomicLong 、AtomicReference

AtomicIntegerArray 、AtomicLongArray

AtomicMarkableReference

AtomicReferenceArray

AtomicStampedReference

JUC的Lock：

而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了一个对象中。这个对象就是Condition，将Object中的三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。

传统synchronized

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

Lock 接口

实现类

在java.util.concurrent.locks 这个包中提供了Lock接口，该接口的定义如下：

public interface Lock { 
    void lock(); 
    void lockInterruptibly(); 
    boolean tryLock(); 
    boolean tryLock(long time, TimeUnit unit) throw InterruptedException; 
    boolean unlock(); 
    Condition newCondition(); 
}

这其中的lock方法和unlock方法没有什么好讲的，其实作用和synchronized(lock)差不多。lock方法会阻塞式的等待锁。

lockInterrupitbly()方法中，获取到锁的线程被中断的时候，会抛出中断异常，并释放持有的锁。使用synchronized关键字获取锁的线程是做不到这一点的。

tryLock()方法则不会阻塞，如果没有获取到锁，会立即返回false，不会一直等待。

tryLock(long time, TimeUnit unit)则会在指定的时间段内等待锁。如果没有等到，则返回false。

最后一个方法newCondition()，这个是用于获取Condition对象，该对象用于线程之间的同步，这里我们就不涉及了。

Lock接口的实现类ReentrantLock

同时，Java还提供了Lock接口的实现类ReentrantLock。从名字上就可以看出，这是一个可重入锁。该类的实现，依赖于其中的一个内部抽象类Sync，该类有两个具体的实现NonfairSync和FairSync。一个用于实现非公平锁，一个用于实现公平锁。具体的获取锁和释放锁的逻辑，其实都在Sync类及其两个子类中。

reentrantLock构造器

public ReentrantLock() {
    sync = new NonfairSync(); //无参默认非公平锁
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();//传参为true为公平锁
}

公平锁: 十分公平: 可以先来后到,一定要排队

非公平锁: 十分不公平,可以插队(默认)

ReentrantLock是怎样实现可重入的呢？在ReentrantLock中，会有一个变量用来保存当前持有锁的线程对象。（实际上是在Sync对象中持有该变量，为了叙述方便，后面不再详细区分，有兴趣的可以自己看看源码。）

 protected final boolean tryAcquire(int acquires) { 
        final Thread current = Thread.currentThread(); //获取当前线程
        int c = getState(); //获取当前同步状态的值
        if (c == 0) { //当前同步状态没有被任何线程获取的时候
            if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { 
                setExclusiveOwnerThread(current); 
                return true; 
            } 
        }  else if (current == getExclusiveOwnerThread()) { 
            int nextc = c + acquires; 
            if (nextc < 0) 
                throw new Error("Maximum lock count exceeded"); 
            setState(nextc); 
            return true; 
        } 
        return false; 
    } 
}

上面的代码主要是一个if...else...语句。主体的逻辑是：

• 如果当前锁没有给任何线程持有，则直接获取锁（获取锁的方式使用的是compareAndSetState，底层实际上使用的是Compare And Swap（CAS）机制来实实现的）。获取成功则返回true来表示获取锁成功。
• 如果当前锁已经被其他线程持有，那么判断持有锁的线程是否是当前线程，如果是的话，则增加锁的计数，返回true，表示获取锁成功。
• 如果前面两条都没有成功，则返回false，表示获取锁失败。

可重入锁的释放也不是立即直接释放，而是每次减少计数，直到计数为0。如下面的代码所示：

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

在实例化ReentrantLock类的时候，可以传入一个boolean类型的参数，用于指定是需要公平锁还是非公平锁（默认是非公平锁）。

通常来说，该类的使用方式如下：

private Lock lock = new ReentrantLock();   // 默认使用非公平锁
    public void someMethodUsingLock(){
  ......
        lock.lock();
        try{
     ......
        } catch (Exception e){
    ......
        } finally {
            lock.unlock();
        }
    }

上面的代码中，我们没有将lock.lock()这一行代码放在try中，是因为如果放在try中，并且在执行这一行代码的时候抛出了异常，那么就会进入finally的代码块中，会执行lock.unlock()，但是实际上当前线程可能并没有获取到锁，执行unlock又会抛出异常。

可重入特性实现了，那么公平/非公平又是怎么实现的？公平和非公平在tryLock(long time, TimeUnit unit)这个方法中有不同。我们一直跟踪到具体实现，让我们看看代码：

非公平锁的实现代码
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}
公平锁的实现代码
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

可以看到，唯一的不同就是一个调用，公平锁在获取锁之前，调用了!hasQueuedPredecessors()，先判断是否有其他的线程已经在排队了。

SaleTicketDemo

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

public class SaleTicketDemo {

    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(()->{for(int i = 0; i < 40; i++) ticket.sale();}, "a").start();
        new Thread(()->{for(int i = 0; i < 40; i++) ticket.sale();}, "b").start();
        new Thread(()->{for(int i = 0; i < 40; i++) ticket.sale();}, "c").start();

    }
}

class Ticket {

    private int ticketNum = 6;
    // 非公平锁只会输出A    private Lock lock = new ReentrantLock();
    // 公平锁a,b,c轮询输出  private Lock lock = new ReentrantLock(true);
    private Lock lock = new ReentrantLock(true);

    public void sale() {
        lock.lock();
        try {
            if (this.ticketNum > 0) {
                System.out.println(Thread.currentThread().getName() + "购得第" + ticketNum-- + "张票, 剩余" + ticketNum + "张票");
            }
            //增加错误的发生几率
            Thread.sleep(10);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

公平锁输出结果

非公平锁输出结果

读写锁接口ReadWriteLock

在最开始的一篇文章中，我们已经提到了读写锁，并且说读写锁其实是一个组合锁。我们来看看Java中给出的ReadWriteLock接口：

public interface ReadWriteLock {
        Lock readLock();
        Lock writeLock();
}

在Java给出的实现类ReentrantReadWriteLock中，分别实现了ReadLock和WriteLock类。它们的不同在于，在ReadLock的中，获取锁的代码是

public void lock() {
    sync.acquireShared(1);
}

但是在WriteLock中，获取锁的代码是

public void lock() {
    sync.acquire(1);
}

从名字上就可以看出，一个是共享锁，一个是排他锁。具体的实现方式，大家可以自己去看看源代码。

乐观读写锁StampedLock

前面我们介绍的这些锁的实现，都是悲观锁，包括上面的ReentrantReadWriteLock。在ReentrantReadWriteLock中，在读的时候是不能写的，在写的时候也是不能读的。

在Java 8中，又引入了另外一种读写锁，StampedLock。这个锁和前面的ReentrantReadWriteLock的不同之处在于，StampedLock中，如果有线程获取了读锁，正在读取数据，另外一个线程可以获取写锁来写数据。 因此这种锁是一种乐观锁（至少在这种情况下是）。但是乐观锁带来的问题是读取的数据可能不一致，因此需要额外的代码来判断。大致的代码如下：

StampedLock stampedLock = new StampedLock();
    long stamp = stampedLock.tryOptimisticRead(); // 获得一个乐观读锁
.......   //读取数据，可能是读取多个数据
        if (!stampedLock.validate(stamp)) { // 检查乐观读锁后是否有其他写锁发生
           //说明读取过程中有写入操作，因此可能读取到错误的数据
           stamp = stampedLock.readLock(); // 获取一个悲观读锁
        try {
        ......  //重新读取数据
        } finally {
            stampedLock.unlockRead(stamp); // 释放悲观读锁
        }
    }

小结

Java中提供了一些锁的接口和实现类，包括普通的Lock接口，ReadWriteLock接口，并且提供了相应的实现ReentrantLock，ReentrantReadWriteLock，StampedLock。

JUC的Condition 精准的通知和唤醒线程

Condition是个接口，基本的方法就是await()和signal()方法；

Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()。

调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用。

Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个Lock 可能与多个Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的Object 版本中的不同。

Condition 实例实质上被绑定到一个锁上。要为特定Lock 实例获得Condition 实例，请使用其newCondition() 方法。

Conditon中的await()对应Object的wait()；

Condition中的signal()对应Object的notify()；

Condition中的signalAll()对应Object的notifyAll()。

Condition常见例子（生产者消费者模式（完成加一减一各一次操作））：

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

public class ConditionTest {
    public static void main(String[] args) {
        NewConditionTest a = new NewConditionTest();
        new Thread(()->{
            for (int i =0;i<10;i++){
                a.increment();
            }
        },"A").start();
        new Thread(()->{
            for (int i =0;i<10;i++){
                a.decrease();
            }
        },"B").start();


    }

}
class  NewConditionTest{
    public int nummber=0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public   void  increment(){
        lock.lock();
        try {
            while(nummber!=0){
                condition.await();
            }
            nummber++;
            System.out.println(Thread.currentThread().getName()+">>"+nummber);
            condition.signalAll();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public  void decrease(){
        lock.lock();
        try {
            while(nummber!=1){
                condition.await();
            }
            nummber--;
            System.out.println(Thread.currentThread().getName()+">>"+nummber);
            condition.signalAll();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行结果

集合类不安全

list 不安全

list 不安全
//java.util.ConcurrentModificationException 并发修改异常!
public class ListTest {

    public static void main(String[] args) {
        //并发下 arrayList 是不安全的
        /**
         * 解决方案
         * 1. 使用vector解决
         * 2. List<String> arrayList = Collections.synchronizedList(new ArrayList<>());
         * 3. List<String> arrayList = new CopyOnWriteArrayList<>();
         */
        //copyOnWrite 写入时复制  COW 计算机程序设计领域的一种优化策略
        //多个线程调用的时候, list, 读取的时候固定的,写入的时候,可能会覆盖
        //在写入的时候避免覆盖造成数据问题
        //CopyOnWriteArrayList 比 vector牛逼在哪里

        //读写分离
        List<String> arrayList = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                arrayList.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(arrayList);
            },String.valueOf(i)).start();
        }
        //安全
        List<String> arrayList = Collections.synchronizedList(new ArrayList<>());;
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                arrayList.add( UUID.randomUUID().toString().substring(0,5));
                System.err.println(arrayList);
            },String.valueOf(i)).start();
        }
    }
}

set 不安全

/**
 * 同理可证
 */
public class SetTest {
    public static void main(String[] args) {
        //        Set<String> set = new HashSet<>();
        //如何解决hashSet线程安全问题
        //1. Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set1 = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                set1.add( UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set1);
            }, String.valueOf(i)).start();
        }

        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                set.add( UUID.randomUUID().toString().substring(0, 5));
                System.err.println(set);
            }, String.valueOf(i)).start();
        }
    }
}

hashSet底层是什么? hashMap

public HashSet() {
    map = new HashMap<>();
}
// add 的本质就是 map 的 key key是无法重复的
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
private static final Object PRESENT = new Object();//这是一个不变的值

HashMap 不安全

map的基本操作

HashTable、SynchronizedMap、ConcurrentHashMap这三种是实现线程安全的Map。

HashTable：是直接在操作方法上加synchronized关键字，锁住整个数组，粒度比较大；

SynchronizedMap：是使用Collections集合工具的内部类，通过传入Map封装出一个SynchronizedMap对象，内部定义了一个对象锁，方法内通过对象锁实现；

Map<Object, Object> map = Collections.synchronizedMap(  new HashMap<>());;
    for (int i = 0; i < 10; i++) {
        new Thread(()->{
            map.put( UUID.randomUUID().toString().substring(0,5),UUID.randomUUID().toString().substring(0,5));
            System.err.println(map);
        },String.valueOf(i)).start();
    }
}

ConcurrentHashMap：使用分段锁（CAS + synchronized相结合），降低了锁粒度，大大提高并发度。

ConcurrentHashMap

1 ConcurrentHashMap默认初始容量为16

2 ConCurrentHashmap如果key或者value为null会抛出空指针异常

3 ConCurrentHashmap 每次扩容是原来容量2倍 在transfer方法里面会创建一个原数组的俩倍的node数组来存放原数据。

4 ConCurrentHashmap的数据结构在java1.8中，它是一个数组+链表+红黑树的数据结构。

5 存储在ConCurrentHashmap中每个节点是什么样的，有哪些变量

它是实现Map.Entry<K,V>接口。里面存放了hash，key，value，以及next节点。它的value和next节点是用volatile进行修饰，可以保证多线程之间的可见性。

6 ConCurrentHashmap的put过程是怎样的？

整体流程跟HashMap比较类似，大致是以下几步：

如果桶数组未初始化，则初始化；

如果待插入的元素所在的桶为空，则尝试把此元素直接插入到桶的第一个位置；

如果正在扩容，则当前线程一起加入到扩容的过程中；

如果待插入的元素所在的桶不为空且不在迁移元素，则锁住这个桶（分段锁）；

如果当前桶中元素以链表方式存储，则在链表中寻找该元素或者插入元素；

如果当前桶中元素以红黑树方式存储，则在红黑树中寻找该元素或者插入元素；

如果元素存在，则返回旧值；

如果元素不存在，整个Map的元素个数加1，并检查是否需要扩容；

添加元素操作中使用的锁主要有（自旋锁 + CAS + synchronized + 分段锁）。

7 java1.8中ConCurrentHashmap节点是尾插还是头插？

尾插法,见上述put方法。

8 java1.8中，ConCurrentHashmap什么情况下链表才会转换成红黑树进行存储？

链表长度大于8。数组长度大于64。从put源码和以下源码可以看出：并非一开始就创建红黑树结构，如果当前Node数组长度小于阈值MIN_TREEIFY_CAPACITY，默认为64，先通过扩大数组容量为原来的两倍以缓解单个链表元素过大的性能问题。

9 java1.8中，ConCurrentHashmap的get过程是怎样的？

计算 hash 值

根据 hash 值找到数组对应位置: (n - 1) & h

根据该位置处节点性质进行相应查找

如果该位置为 null，那么直接返回 null 就可以了

如果该位置处的节点刚好就是我们需要的，返回该节点的值即可

如果该位置节点的 hash 值小于 0，说明正在扩容，或者是红黑树，后面我们再介绍 find 方法如果以上 3 条都不满足，那就是链表，进行遍历比对即可

10 java1.8中，ConCurrentHashmap是如何计算它的size大小的？

对于size的计算，在扩容和addCount()方法就已经有处理了，可以注意一下Put函数，里面就有函数。

11 ConcurrentHashMap有哪些构造函数？

一共有五个，作用及代码如下：

//无参构造函数
    public ConcurrentHashMap() {
    }
    //可传初始容器大小的构造函数
    public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        this.sizeCtl = cap;
    }
    //可传入map的构造函数
    public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
        this.sizeCtl = DEFAULT_CAPACITY;
        putAll(m);
    }
    //可设置阈值和初始容量
    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, 1);
    }

    //可设置初始容量和阈值和并发级别
    public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
        this
    }

12 ConcurrentHashMap使用什么技术来保证线程安全？

jdk1.7：Segment+HashEntry来进行实现的；

jdk1.8：放弃了Segment臃肿的设计，采用Node+CAS+Synchronized来保证线程安全；

13 ConcurrentHashMap的get方法是否要加锁，为什么？

不需要，get方法采用了unsafe方法，来保证线程安全。

14 ConcurrentHashMap迭代器是强一致性还是弱一致性？HashMap呢？

弱一致性，HashMap强一直性。

ConcurrentHashMap可以支持在迭代过程中，向map添加新元素，而HashMap则抛出了ConcurrentModificationException，因为HashMap包含一个修改计数器，当你调用他的next()方法来获取下一个元素时，迭代器将会用到这个计数器。

15 ConcurrentHashMap1.7和1.8的区别

jdk1.8的实现降低锁的粒度，jdk1.7锁的粒度是基于Segment的，包含多个HashEntry，而jdk1.8锁的粒度就是Node

数据结构：jdk1.7 Segment+HashEntry；jdk1.8 数组+链表+红黑树+CAS+synchronized

常用的辅助类

CountDownLatch

Java 5.0 在java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。

countDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。是多线程控制的一种工具，它被称为 门阀、 计数器或者 闭锁。这个工具经常用来用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。

闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行：

确保某个计算在其需要的所有资源都被初始化之后才继续执行;

确保某个服务在其依赖的所有其他服务都已经启动之后才启动;

等待直到某个操作所有参与者都准备就绪再继续执行。

认识 CountDownLatch

CountDownLatch 能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。它相当于是一个计数器，这个计数器的初始值就是线程的数量，每当一个任务完成后，计数器的值就会减一，当计数器的值为0时，表示所有的线程都已经任务了，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

测试

//计数器
public class CountDownLatchTest{
    public static void main(String[] args) throws InterruptedException {
        //相当于计数器
        CountDownLatch countDownLatch = new CountDownLatch(5);
        //计数器总数是5,当减少为0,任务才继续向下执行
        for (int i = 1; i <6 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"==>start");
                countDownLatch.countDown();
            }).start();
        }
        countDownLatch.await();
        System.out.println("main线程继续向下执行");
    }
}

结果：

原理:

countDownLatch.countDown(); //数量减1

countDownLatch.await();// 等待计数器归零,然后再向下执行

每次有线程调用countDown()数量-1,假设计数器变为0,countDownLatch.await();就会被唤醒,继续执行

CountDownLatch 的使用

CountDownLatch提供了一个构造方法，你必须指定其初始值，还指定了countDown方法，这个方法的作用主要用来减小计数器的值，当计数器变为0时，在CountDownLatch上await的线程就会被唤醒，继续执行其他任务。当然也可以延迟唤醒，给CountDownLatch加一个延迟时间就可以实现。

其主要方法如下

CountDownLatch 应用场景

典型的应用场景就是当一个服务启动时，同时会加载很多组件和服务，这时候主线程会等待组件和服务的加载。当所有的组件和服务都加载完毕后，主线程和其他线程在一起完成某个任务。

CountDownLatch 还可以实现学生一起比赛跑步的程序，CountDownLatch 初始化为学生数量的线程，鸣枪后，每个学生就是一条线程，来完成各自的任务，当第一个学生跑完全程后，CountDownLatch 就会减一，直到所有的学生完成后，CountDownLatch 会变为 0 ，接下来再一起宣布跑步成绩。

顺着这个场景，你自己就可以延伸、拓展出来很多其他任务场景。

CountDownLatch 用法

下面我们通过一个简单的计数器来演示一下 CountDownLatch 

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest02 {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(5);
        Increment increment = new Increment(latch);
        Decrement decrement = new Decrement(latch);
        new Thread(increment).start();
        new Thread(decrement).start();
    }
}

class Decrement implements Runnable {
    CountDownLatch countDownLatch;
    public Decrement(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        try {

            for(long i = countDownLatch.getCount();i > 0;i--){
                Thread.sleep(1000);
                System.out.println("countdown");
                this.countDownLatch.countDown();
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class Increment implements Runnable {
    CountDownLatch countDownLatch;
    public Increment(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        try {
            System.out.println("await");
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Waiter Released");
    }
}

在main方法中我们初始化了一个计数器为5的CountDownLatch，在Decrement方法中我们使用countDown执行减一操作，然后睡眠一段时间，同时在Increment类中进行等待，直到Decrement中的线程完成计数减一的操作后，唤醒Increment类中的run方法，使其继续执行。

下面我们再来通过学生赛跑这个例子来演示一下CountDownLatch的具体用法

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

public class CountDownLatchTest03{
    CountDownLatch stopLatch = new CountDownLatch(1);
    CountDownLatch runLatch = new CountDownLatch(10);

    public void waitSignal() throws Exception{
        System.out.println("选手" + Thread.currentThread().getName() + "正在等待裁判发布口令");
        stopLatch.await();
        System.out.println("选手" + Thread.currentThread().getName() + "已接受裁判口令");
        Thread.sleep((long) (Math.random() * 10000));
        System.out.println("选手" + Thread.currentThread().getName() + "到达终点");
        runLatch.countDown();
    }

    public void waitStop() throws Exception{
        Thread.sleep((long) (Math.random() * 4000));
        System.out.println("裁判"+Thread.currentThread().getName()+"即将发布口令");
        stopLatch.countDown();
        System.out.println("裁判"+Thread.currentThread().getName()+"已发送口令，正在等待所有选手到达终点");
        runLatch.await();
        System.out.println("所有选手都到达终点");
        System.out.println("裁判"+Thread.currentThread().getName()+"汇总成绩排名");
    }

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        CountDownLatchTest03 studentRunRace = new CountDownLatchTest03();
        for (int i = 0; i < 10; i++) {
            Runnable runnable = () -> {
                try {
                    studentRunRace.waitSignal();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            };
            service.execute(runnable);
        }
        try {
            studentRunRace.waitStop();
        } catch (Exception e) {
            e.printStackTrace();
        }
        service.shutdown();
    }
}

下面我们就来一起分析一下 CountDownLatch 的源码

CountDownLatch 源码分析

CountDownLatch 使用起来比较简单，但是却非常有用，现在你可以在你的工具箱中加上 CountDownLatch 这个工具类了。下面我们就来深入认识一下 CountDownLatch。

CountDownLatch 的底层是由 AbstractQueuedSynchronizer 支持，而 AQS 的数据结构的核心就是两个队列，一个是同步队列(sync queue)，一个是条件队列(condition queue)。

Sync 内部类

CountDownLatch 在其内部是一个Sync，它继承了AQS抽象类。

private static final class Sync extends AbstractQueuedSynchronizer{...}
CountDownLatch其实其内部只有一个sync属性，并且是final的
private final Sync sync;
CountDownLatch只有一个带参数的构造方法
public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}
也就是说，初始化的时候必须指定计数器的数量，如果数量为负会直接抛出异常。
然后把 count 初始化为Sync内部的count，也就是
Sync(int count) {
    setState(count);
}

注意这里有一个setState(count)，这是什么意思呢？见闻知意这只是一个设置状态的操作，但是实际上不单单是，还有一层意思是state的值代表着待达到条件的线程数。这个我们在聊countDown方法的时候再讨论。

getCount()方法的返回值是getState()方法，它是AbstractQueuedSynchronizer中的方法，这个方法会返回当前线程计数，具有volatile读取的内存语义。

// ---- CountDownLatch ----
int getCount() {
    return getState();
}
// ---- AbstractQueuedSynchronizer ----
protected final int getState() {
    return state;
}
tryAcquireShared() 方法用于获取·共享状态下对象的状态，判断对象是否为 0 ，如果为 0 返回 1 ，表示能够尝试获取，如果不为 0，那么返回 -1，表示无法获取。
protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}
// ----  getState() 方法和上面的方法相同 ----
这个 共享状态 属于 AQS 中的概念，在 AQS 中分为两种模式，一种是 独占模式，一种是 共享模式。
•	tryAcquire 独占模式，尝试获取资源，成功则返回 true，失败则返回 false。
•	tryAcquireShared 共享方式，尝试获取资源。负数表示失败；0 表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared() 方法用于共享模式下的释放
protected boolean tryReleaseShared(int releases) {
    // 减小数量，变为 0 的时候进行通知
    for (;;) {
        int c = getState();
        if (c == 0)
            return false;
        int nextc = c - 1;
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

这个方法是一个无限循环，获取线程状态，如果线程状态是 0 则表示没有被线程占有，没有占有的话那么直接返回 false ，表示已经释放；然后下一个状态进行 - 1 ，使用 compareAndSetState CAS 方法进行和内存值的比较，如果内存值也是 1 的话，就会更新内存值为 0 ，判断 nextc 是否为 0 ，如果 CAS 比较不成功的话，会再次进行循环判断。

如果 CAS 用法不清楚的话，读者朋友们可以参考这篇文章 告诉你一个 AtomicInteger 的惊天大秘密！

await 方法

await()方法是CountDownLatch一个非常重要的方法，基本上可以说只有countDown和await方法才是CountDownLatch的精髓所在，这个方法将会使当前线程在CountDownLatch计数减至零之前一直等待，除非线程被中断。

CountDownLatch中的await方法有两种，一种是不带任何参数的await()，一种是可以等待一段时间的await(long timeout, TimeUnit unit)。下面我们先来看一下 await() 方法。

public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
public boolean await(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
await方法内部会调用acquireSharedInterruptibly方法，这个acquireSharedInterruptibly是AQS中的方法，以共享模式进行中断。
public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}
可以看到，acquireSharedInterruptibly 方法的内部会首先判断线程是否中断，如果线程中断，则直接抛出线程中断异常。如果没有中断，那么会以共享的方式获取。如果能够在共享的方式下不能获取锁，那么就会以共享的方式断开链接。
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED);
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } catch (Throwable t) {
        cancelAcquire(node);
        throw t;
    }
}
这个方法有些长，我们分开来看
•	首先，会先构造一个共享模式的 Node 入队
•	然后使用无限循环判断新构造 node 的前驱节点，如果 node 节点的前驱节点是头节点，那么就会判断线程的状态，这里调用了一个 setHeadAndPropagate ,其源码如下
•	private void setHeadAndPropagate(Node node, int propagate) {
•	    Node h = head; // Record old head for check below
•	    setHead(node);
•	    /*
•	     * Try to signal next queued node if:
•	     *   Propagation was indicated by caller,
•	     *     or was recorded (as h.waitStatus either before
•	     *     or after setHead) by a previous operation
•	     *     (note: this uses sign-check of waitStatus because
•	     *      PROPAGATE status may transition to SIGNAL.)
•	     * and
•	     *   The next node is waiting in shared mode,
•	     *     or we don't know, because it appears null
•	     *
•	     * The conservatism in both of these checks may cause
•	     * unnecessary wake-ups, but only when there are multiple
•	     * racing acquires/releases, so most need signals now or soon
•	     * anyway.
•	     */
•	    if (propagate > 0 || h == null || h.waitStatus < 0 ||
•	        (h = head) == null || h.waitStatus < 0) {
•	        Node s = node.next;
•	        if (s == null || s.isShared())
•	            doReleaseShared();
•	    }
•	}
首先会设置头节点，然后进行一系列的判断，获取节点的获取节点的后继，以共享模式进行释放，就会调用 doReleaseShared 方法，我们再来看一下 doReleaseShared 方法
private void doReleaseShared() {
    /*
     * Ensure that a release propagates, even if there are other
     * in-progress acquires/releases.  This proceeds in the usual
     * way of trying to unparkSuccessor of head if it needs
     * signal. But if it does not, status is set to PROPAGATE to
     * ensure that upon release, propagation continues.
     * Additionally, we must loop in case a new node is added
     * while we are doing this. Also, unlike other uses of
     * unparkSuccessor, we need to know if CAS to reset status
     * fails, if so rechecking.
     */
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !h.compareAndSetWaitStatus(0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

这个方法会以无限循环的方式首先判断头节点是否等于尾节点，如果头节点等于尾节点的话，就会直接退出。如果头节点不等于尾节点，会判断状态是否为 SIGNAL，不是的话就继续循环 compareAndSetWaitStatus，然后断开后继节点。如果状态不是 SIGNAL，也会调用 compareAndSetWaitStatus 设置状态为 PROPAGATE，状态为 0 并且不成功，就会继续循环。

也就是说 setHeadAndPropagate 就是设置头节点并且释放后继节点的一系列过程。

• 我们来看下面的 if 判断，也就是 shouldParkAfterFailedAcquire(p, node) 这里

if (shouldParkAfterFailedAcquire(p, node) &&
    parkAndCheckInterrupt())
  throw new InterruptedException();

如果上面 Node p = node.predecessor() 获取前驱节点不是头节点，就会进行 park 断开操作，判断此时是否能够断开，判断的标准如下

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
  int ws = pred.waitStatus;
  if (ws == Node.SIGNAL)
    return true;
  if (ws > 0) {
    do {
      node.prev = pred = pred.prev;
    } while (pred.waitStatus > 0);
    pred.next = node;
  } else {
    compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
  }
  return false;
} 

这个方法会判断 Node p 的前驱节点的结点状态(waitStatus)，节点状态一共有五种，分别是

1. CANCELLED(1)：表示当前结点已取消调度。当超时或被中断（响应中断的情况下），会触发变更为此状态，进入该状态后的结点将不会再变化。
2. SIGNAL(-1)：表示后继结点在等待当前结点唤醒。后继结点入队时，会将前继结点的状态更新为 SIGNAL。
3. CONDITION(-2)：表示结点等待在 Condition 上，当其他线程调用了 Condition 的 signal() 方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁。
4. PROPAGATE(-3)：共享模式下，前继结点不仅会唤醒其后继结点，同时也可能会唤醒后继的后继结点。
5. 0：新结点入队时的默认状态。

如果前驱节点是 SIGNAL 就会返回 true 表示可以断开，如果前驱节点的状态大于 0 (此时为什么不用 ws == Node.CANCELLED ) 呢？因为 ws 大于 0 的条件只有 CANCELLED 状态了。然后就是一系列的查找遍历操作直到前驱节点的 waitStatus > 0。如果 ws <= 0 ，而且还不是 SIGNAL 状态的话，就会使用 CAS 替换前驱节点的 ws 为 SIGNAL 状态。

如果检查判断是中断状态的话，就会返回 false。

private final boolean parkAndCheckInterrupt() {
  LockSupport.park(this);
  return Thread.interrupted();
} 

这个方法使用 LockSupport.park 断开连接，然后返回线程是否中断的标志。

• cancelAcquire() 用于取消等待队列，如果等待过程中没有成功获取资源（如timeout，或者可中断的情况下被中断了），那么取消结点在队列中的等待。

private void cancelAcquire(Node node) {
  if (node == null)
    return;

  node.thread = null;
  
  Node pred = node.prev;
  while (pred.waitStatus > 0)
    node.prev = pred = pred.prev;

  Node predNext = pred.next;

  node.waitStatus = Node.CANCELLED;

  if (node == tail && compareAndSetTail(node, pred)) {
    compareAndSetNext(pred, predNext, null);
  } else {
    int ws;
    if (pred != head &&
        ((ws = pred.waitStatus) == Node.SIGNAL ||
         (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
        pred.thread != null) {
      Node next = node.next;
      if (next != null && next.waitStatus <= 0)
        compareAndSetNext(pred, predNext, next);
    } else {
      unparkSuccessor(node);
    }
    node.next = node; // help GC
  }
} 

所以，对 CountDownLatch 的 await 调用大致会有如下的调用过程。

一个和await重载的方法是await(long timeout, TimeUnit unit)，这个方法和await最主要的区别就是这个方法能够可以等待计数器一段时间再执行后续操作。

countDown方法

countDown是和await同等重要的方法，countDown用于减少计数器的数量，如果计数减为0的话，就会释放所有的线程。

/**
 * Decrements the count of the latch, releasing all waiting threads if
 * the count reaches zero.
 *
 * <p>If the current count is greater than zero then it is decremented.
 * If the new count is zero then all waiting threads are re-enabled for
 * thread scheduling purposes.
 *
 * <p>If the current count equals zero then nothing happens.
 */
public void countDown() {
    sync.releaseShared(1);
}

这个方法会调用 releaseShared 方法，此方法用于共享模式下的释放操作，首先会判断是否能够进行释放，判断的方法就是 CountDownLatch 内部类 Sync 的 tryReleaseShared 方法

/**
 * Releases in shared mode.  Implemented by unblocking one or more
 * threads if {@link #tryReleaseShared} returns true.
 *
 * @param arg the release argument.  This value is conveyed to
 *        {@link #tryReleaseShared} but is otherwise uninterpreted
 *        and can represent anything you like.
 * @return the value returned from {@link #tryReleaseShared}
 */
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}
// ---- CountDownLatch ----
    protected boolean tryReleaseShared(int releases) {
        // Decrement count; signal when transition to zero
        for (;;) {
            int c = getState();
            if (c == 0)
                return false;
            int nextc = c-1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;
        }
    }
}
tryReleaseShared 会进行 for 循环判断线程状态值，使用 CAS 不断尝试进行替换。
如果能够释放，就会调用 doReleaseShared 方法
/**
 * Release action for shared mode -- signals successor and ensures
 * propagation. (Note: For exclusive mode, release just amounts
 * to calling unparkSuccessor of head if it needs signal.)
 */
private void doReleaseShared() {
    /*
     * Ensure that a release propagates, even if there are other
     * in-progress acquires/releases.  This proceeds in the usual
     * way of trying to unparkSuccessor of head if it needs
     * signal. But if it does not, status is set to PROPAGATE to
     * ensure that upon release, propagation continues.
     * Additionally, we must loop in case a new node is added
     * while we are doing this. Also, unlike other uses of
     * unparkSuccessor, we need to know if CAS to reset status
     * fails, if so rechecking.
     */
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

可以看到，doReleaseShared其实也是一个无限循环不断使用CAS尝试替换的操作。

总结

本文是 CountDownLatch的基本使用和源码分析，CountDownLatch就是一个基于 AQS 的计数器，它内部的方法都是围绕 AQS 框架来谈的，除此之外还有其他比如 ReentrantLock、Semaphore 等都是 AQS 的实现，所以要研究并发的话，离不开对 AQS 的探讨。CountDownLatch 的源码看起来很少，比较简单，但是其内部比如await方法的调用链路却很长，也值得花费时间深入研究。

cyclicBarrier

加法计数器

public class CyclicBarrierTest {

    public static void main(String[] args) {
        /**
         * 集齐77个龙珠召唤神龙，召唤龙珠的线程
         */ 
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, ()->{
            System.out.println("召唤神龙成功! ");
        });
        for (int i = 0; i < 7; i++) {
            int temp = i;
            //lambda 能拿到i吗
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "收集" + temp + "个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

运行结果：

Semaphore

public class SemaphoreTest {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 6; i++) {
            int temp = i;
            new Thread(()->{
                try {
                    semaphore.acquire(); //获取
                    System.out.println(temp + "号车抢到车位");
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); //释放
                    System.out.println(temp + "号车离开车位");
                }
            }).start();
        }
    }
}

运行结果：

原理:

semaphore.acquire(); //获取信号量,假设如果已经满了,等待信号量可用时被唤醒

semaphore.release(); //释放信号量

作用: 多个共享资源互斥的使用!并发限流,控制最大的线程数

新增线程创建方式

新增方式一：实现Callable接口

Java 5.0 在java.util.concurrent 提供了一个新的创建执行线程的方式：Callable 接口。

Callable 接口类似于Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是Runnable不会返回结果，并且无法抛出经过检查的异常

创建执行线程的方式三：实现Callable接口。相较于实现Runnable接口的方式，方法可以有返回值，并且可以抛出异常。执行Callable方式，需要FutureTask实现类的支持，用于接收运算结果。FutureTask是Future接口的实现类。Callable 需要依赖FutureTask ，FutureTask 也可以用作闭锁。

Future接口

    可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。

    FutrueTask是Futrue接口的唯一的实现类。FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

可以有返回值。可以抛出异常。方法不同, run() => call()

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask = new FutureTask<>(new MyThread());
        new Thread(futureTask,"a").start();
        System.out.println(futureTask.get());
    }
}
class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("call()方法被调用了");
        return 1024;
    }
}

新增方式二：使用线程池

线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。

    背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

    思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：

1. 提高响应速度（减少了创建新线程的时间）。
2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）。
3. 便于线程管理。
4. corePoolSize：核心池的大小。
5. maximumPoolSize：最大线程数。
6. keepAliveTime：线程没有任务时最多保持多长时间后会终止。

    JDK 5.0起提供了线程池相关API：ExecutorService和Executors
    ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
        void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
        <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行Callable
        void shutdown() ：关闭连接池
为了便于跨大量上下文使用，此类提供了很多可调整的参数和扩展钩子(hook)。但是，强烈建议程序员使用较为方便的Executors 工厂方法：
    Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
        Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池（无界线程池，可以进行自动线程回收）
        Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
        Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
        Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
它们均为大多数使用场景预定义了设置。

(4)线程组

/**
 * @author 牛晨洋
 * 线程组：把多个线程组合到一起
 *      他可以对一批线程进行分类管理，java允许程序对线程组进行控制
 */
public class ThreadGroupDemo {
    public static void main(String[] args) {
        method1();
        // 我们如何修改线程所在的组？
        // 创建一个线程组的时候，把其他线程的组指定为我们自己新建的线程组
        // method2();

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

    private static void method1() {
        MyRunnable my = new MyRunnable();
        Thread t1 = new Thread(my, "张三");
        Thread t2 = new Thread(my, "李四");
        // 我不知道他们属于哪个线程组，但是想知道
        // 线程中的方法：public final ThreadGroup getThreadGroup()
        ThreadGroup tg1 = t1.getThreadGroup();
        ThreadGroup tg2 = t2.getThreadGroup();
        // 线程组里面的方法： public final string getName()
        String name1 = tg1.getName();
        String name2 = tg2.getName();

        t1.start();
        t2.start();
        System.out.println(name1);
        System.out.println(name2);

        // 通过测试我们知道：线程默认是属于main线程组
        // 通过测试，默认情况下，所有线程都属于一个组
        System.out.println(Thread.currentThread().getThreadGroup().getName());
    }

    private static void method2() {
        // ThreadGrop(String name);
        ThreadGroup tg = new ThreadGroup("这是一个新的组");
        MyRunnable my = new MyRunnable();
        // Thread(ThreadGrop group, Runnable target, String name)
        Thread t1 = new Thread(tg, my, "张三");
        Thread t2 = new Thread(tg, my, "李四");

        t1.start();
        t2.start();
        System.out.println(t1.getThreadGroup().getName());
        System.out.println(t2.getThreadGroup().getName());
        // 通过组名设置后台线程，标识该组的线程都是后台线程
        tg.setDaemon(true);
    }
}

class MyRunnable implements Runnable {

    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

(5)线程池

/**
 *   线程池的好处线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用
 *   如何实现线程的代码：
 *      A 创建一个线程池对象，控制要创建的几个线程对象。
 *          public static ExectorService new FixedThreadpool (int nThreads);
 *      B 这种线程池的线程可以执行：
 *         可以执行Runnable对象或者Callable对象代表的线程
 *         做一个实现Runnable的接口
 *      C 调用方法如下：
 *          Future<?> submit (Runnable task)
 *          <T> Future<T> submit (Callable<T> task)
 *      D 可以结束：
 **/
public class ThreadGroupDemo {
    public static void main(String[] args) {
        // 创建一个线程池对象，控制要创建的几个线程对象。
        // public static ExectorService new FixedThreadpool (int nThreads);
        ExecutorService pool = Executors.newCachedThreadPool();

        // 可以执行Runnable对象或者Callable 对象代表的线程
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        // 结束线程池
        pool.shutdown();
    }
}

class MyRunnable implements Runnable {

    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

(6)多线程实现的第三种方案

案例1:
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 *   线程池的好处线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用
 *   如何实现线程的代码：
 *      A 创建一个线程池对象，控制要创建的几个线程对象。
 *          public static ExectorService new FixedThreadpool (int nThreads);
 *      B 这种线程池的线程可以执行：
 *         可以执行Runnable对象或者Callable对象代表的线程
 *         做一个实现Runnable的接口
 *      C 调用方法如下：
 *          Future<?> submit (Runnable task)
 *          <T> Future<T> submit (Callable<T> task)
 *      D 可以结束：
 **/
public class ThreadGroupDemo {
    public static void main(String[] args) {
        // 创建一个线程池对象，控制要创建的几个线程对象。
        // public static ExectorService new FixedThreadpool (int nThreads);
        ExecutorService pool = Executors.newCachedThreadPool();
        // 可以执行Runnable对象或者Callable 对象代表的线程
        Future<Integer> f1 = pool.submit(new MyCallable(100));
        Future<Integer> f2 = pool.submit(new MyCallable(100));

        Integer i1 = null;
        Integer i2 = null;
        try {
            i1 = f1.get();
            i2 = f2.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(i1);
        System.out.println(i2);
        // 结束线程池
        pool.shutdown();
    }
}
案例2:
/**
 *   匿名内部类的格式：
 *   new 类名或者接口名（）{
 *      重写方法
 *   }
 *   本质：是该类或者接口的子类对象。
 **/
public class ThreadDemo {
    public static void main(String[] args) {
        // 继承Thread类来实现多线程
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }.start();
        // 实现Runnable接口来实现多线程
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }).start();
        // 结合
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("实现:" + i);
                }
            }
        }) {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }.start();
    }
}
案例3:
定时器：可以让我们在指定的时间做某件事情，还可以重复的做某件事情。
import java.util.Timer;
import java.util.TimerTask;

/**
 *   定时器：可以让我们在指定的时间做某件事情，还可以重复的做某件事情。
 *   依赖Timer和TimerTask这两个类：
 *   Timer:定时
 *      public Timer()
 *      public void schedule (TimerTask task, long delay)
 *      public void schedule (TimerTask task, long delay, long period)
 *      public void cancel()
 *   TimerTask:任务
 **/
public class TimerDemo2 {
    public static void main(String[] args) {
        // 创建定时器对象
        Timer timer = new Timer();
        // 三秒后执行任务，如果不成功，每隔两秒再继续
        timer.schedule(new MyTask2(), 3000, 2000);
    }
}
class MyTask2 extends TimerTask {
    @Override
    public void run() {
        System.out.println("beng,爆炸了");
    }
}
package com.multithreading;

import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
在指定的时间删除我们指定的目录
/**  在指定的时间删除我们指定的目录 **/
public class TimerDemo2 {
    public static void main(String[] args) throws ParseException {
        // 创建定时器对象
        Timer timer = new Timer();
        // 三秒后执行任务，如果不成功，每隔两秒再继续
        // timer.schedule(new MyTask2(), 3000, 2000);
        Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2018-01-22 16:30:00");
        timer.schedule(new MyTask2(), date);
    }
}

class MyTask2 extends TimerTask {
    @Override
    public void run() {
        File fileFolder = new File("D:\\360安全浏览器下载\\快剪辑视频");
        deleteFolder(fileFolder);
    }
    // 递归删除目录
    public void deleteFolder(File fileFolder) {
        File[] fileArray = fileFolder.listFiles();
        if (fileArray != null) {
            for (File files : fileArray) {
                if (files.isDirectory()) {
                    deleteFolder(files);
                } else {
                    System.out.println(files.getName() + ":" + files.delete());
                }
            }
            System.out.println(fileFolder.getName() + ":" + fileFolder.delete());
        }
    }
}

一些问题

1:多线程有几种实现方案，分别是哪几种?

两种。继承Thread类，实现Runnable接口，扩展一种：实现Callable接口。这个得和线程池结合。

3:启动一个线程是run()还是start()?它们的区别?

start();

    run():封装了被线程执行的代码,直接调用仅仅是普通方法的调用

    start():启动线程，并由JVM自动调用run()方法

4:sleep()和wait()方法的区别

    sleep():必须指时间;不释放锁。

    wait():可以不指定时间，也可以指定时间;释放锁。

2:同步有几种方式，分别是什么?

import junit.framework.TestCase;

// JUnit3：测试方法命名规则public void test+目标方法名()
public class TestAddOperation extends TestCase {
    public void setUp() throws Exception {
    }

    public void tearDown() throws Exception {
    }

    // 测试AddOperation 类的add方法
    public void testAdd() {
        // 输入值
        int x = 3;
        int y = 5;
        AddOperation instance = new AddOperation();
        int expResult = 8;// 预期结果
        int result = instance.add(x, y);// 获取实际结果
        // 通过断言判断实际结果和预期结果的差异,前者为预期后者为实际
        assertEquals(expResult, result);
    }
}

class AddOperation {
    public int add(int x, int y) {
        int a = x + y;
        return a;
    }
}

import org.junit.Test;

//JUnit4采用注解实现，需要JDK1.5及以上版本
public class Text00 {
    @Test
    public void cc() {
        System.out.println("1111");
    }

    @Test
    public void ccc() {
        System.out.println("1122211");
    }
}

import static org.junit.Assert.assertEquals;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

public class AAAA {

    @Ignore
    // @Ignore放在所有Text上只能输出@BeforeClass和AfterClass下的语句
    @Test
    public void cc1() {
        System.out.println("@Test02");
    }

    @Test
    public void cc6() {
        int a = 5;
        assertEquals(5, a);
        System.out.println("@Test01");
    }

    @Test
    public void cc7() {
        int b = 6;
        assertEquals(6, b);
        System.out.println("@Test03");
    }

    @After
    public void cc2() {
        System.out.println("@After");
    }

    @Before
    public void cc3() {
        System.out.println("@Before");
    }

    @BeforeClass
    public static void cc4() {
        System.out.println("@BeforeClass");
    }

    @AfterClass
    public static void cc5() {
        System.out.println("@AfterClass");
    }
}

import static org.junit.Assert.assertEquals;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class TestCalculator {
    int i = 1;

    Calculator calc = new Calculator();

    @Before
    public void setUp() throws Exception {
        System.out.println("测试前初始值置零！    " + i);
        calc.clear();
    }

    @After
    public void tearDown() throws Exception {
        System.out.println("测试后......" + calc.getResult());
    }

    @Test // 加法
    public void add() {
        calc.add(2);
        calc.add(3);
        int result = calc.getResult();
        assertEquals(5, result);
    }

    @Test // 减法
    public void subtract() {
        calc.add(10);
        calc.subtract(2);
        int result = calc.getResult();
        assertEquals(8, result);
    }

    @Test // 除法
    public void divide() {
        calc.add(8);
        calc.divide(2);
        assert calc.getResult() == 4;
    }

    @Test(expected = ArithmeticException.class)
    public void divideByZero() {
        calc.divide(0);
    }

    // 乘法
//    @Ignore("not Ready Yet Test Multiply")
    @Test
    public void multiply() {
        calc.add(10);
        calc.multiply(10);
        int result = calc.getResult();
        assertEquals(100, result);
    }
}
  public class Calculator{
    //存数运算结果的静态变量
    private static int result;
    //加法
    public void add(int n){
        result = result + n;
    }
    //减法，
    public void subtract(int n){
        result = result - n;
    }
    //乘法，此方法尚未实现
    public void multiply(int n){
        result = result * n;
    }
    //除法
    public void divide(int n){
        result = result / n;
    }
    public void clear() {
        result=0;
        
    }
    public int getResult() {
        return result;
    }
    public void square(int param) {
        result=param;
    }

}
测试集：提供将多个单元测试类组合成一测试集的能力。
import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)
@Suite.SuiteClasses({TestCalculator.class,TestSquare.class,Text00.class})
public class TestAllCalculator{
    
}