第一部分-Java基础-003多线程

学习顺序：
1、基本知识点
2、两种创建方式、区别
3、线程同步三种方法
4、死锁
5、线程通信
6、生产者消费者
7、拓展的两种线程创建方式
---------------------------------------------
一、基本知识点
1、程序、进程、线程
（1）程序：一段静态的代码
（2）进程：正在执行的程序；进程是资源分配的单位，系统为每个进程分配不同的内存区域
（3）线程：程序的一条执行路径；线程是调度和执行的单位，每个线程有独立的运行栈和程序计数器；一个线程的多个线程共享相同的内存地址空间
注意：同一进程的多个线程切换开销小；不同进程的线程切换开销大
2、并行、并发
（1）并行：多个CPU同时执行多个任务
（2）并发：一个CPU执行多个任务（按时间片）
一个java.exe至少有三个线程：main主线程、gc垃圾回收线程、异常处理线程
3、多线程的优点
单核CPU先后完成多个任务比多线程花的时间短，因为多线程有切换开销。那么为什么用多线程？
（1）增强图形化界面用户体验。（360安全中心为例，用户既可以体检，也可以杀毒）
（2）提高CPU利用率。（应该是计算机组成原理的知识吧，我也不知道为啥）
（3）改善程序结构。长进程分为多个线程。
4、多线程应用场景
（1）程序需要执行多个任务
（2）需要一些后台运行的程序
（3）程序需要实现一些需要等待的任务（用户输入、文件读写【比如说下载东西】等）

Java中线程的调度方式

线程生命周期

5、多线程常用方法
（1）运行—>就绪
yield()释放当前线程的CPU执行权
（2）运行---->阻塞
a线程中调用b.join()-----------a阻塞了，直到b执行完，a才结束阻塞
Thread.sleep(long time)：当前线程阻塞time毫秒；try catch包裹，因为父类方法没有throws异常，子类重写的方法就不能throws异常
（3）其他
h1.isActive()：判断当前线程是否存活
注意：start仅仅是让线程进入到就绪状态，运行状态执行的是run方法
二、两种创建方式及区别
1、继承Thread类
（1）每个线程都是一个单独的对象，他们有自己的成员变量，如果要想共享资源，需要加上static关键字
（2）synchronized (Tickets.class)
2、实现Runnable接口
（1）多个线程共享同一个成员变量（不用加static）
（2）synchronized (this)
三、线程同步：卖票案例

//线程不安全代码
public class Tickets implements Runnable{
    private int tickets=100;

    @Override
    public void run() {
        while(true){
            if(tickets>0){
                try{
                    Thread.sleep(300);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"窗口出售第"+(tickets--)+"张票");
            }
        }
    }
}

1、synchronized代码块
同步监视器：任何一个类的对象，都能当同步监视器
要求：多个线程必须共用同一把锁
Runnable中的：
成员变量obj------------------------------正确
局部变量obj（run方法里的）--------错误
Thread：
synchronized (Tickets.class)
2、synchronized方法
Runnable中的同步监视器：this
Thread类：
static synchronized
想要调用getName()---------------Thread.currentThread().getName()-------------因为静态方法里只能调用静态方法
同步监视器：Tickets.class
3、lock锁
有个参数fair，保证公平；默认不公平，因为当公平时，3h的进程先到，3s的进程后到，则3s会等3小时

public class Tickets implements Runnable{
    private int tickets=100;
    private ReentrantLock lock=new ReentrantLock();//有个参数fair，保证公平
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(300);
            } catch (Exception e) {
                e.printStackTrace();
            }
            try{
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(300);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "窗口出售第" + (tickets--) + "张票");
                }
            }finally {
                lock.unlock();
            }
        }
    }
}

**面试题：比较synchronized和lock的区别：
相同：都能解决线程安全
不同：
synchronized执行完同步代码后，自动释放同步监视器
lock需要手动上锁、开锁
注意：lock性能更好，且能扩展（有更多子类） **
四、死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等对方先放弃；出现死锁，不会出现异常，只是所有的线程都处于阻塞状态，无法继续

public class DeadLock {
    public static void main(String[] args) {
        StringBuffer s1=new StringBuffer("");
        StringBuffer s2=new StringBuffer("");
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("b");
                    System.out.println("第一次输出："+s1+""+s2);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("c");
                        s2.append("d");
                        System.out.println("第3次输出："+s1+""+s2);
                    }
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("a");
                    s2.append("b");
                    System.out.println("第2次输出："+s1+""+s2);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append("c");
                        s2.append("d");
                        System.out.println("第4次输出："+s1+""+s2);
                    }
                }
            }
        }).start();
    }
}

五、线程通信
使用两个线程打印1-100，线程1、线程2交替打印

public class PrintNum implements Runnable {
    private int num=1;
    @Override
    public void run() {
        while(true){
            synchronized (this){
                notify();//唤醒阻塞的其他线程，但是自己在锁里面，也就是自己还拿着锁
                if(num<=100){
                    System.out.println("线程"+Thread.currentThread().getName()+"打印数字："+(num++));
                }
                try {
                    wait();     //当前的线程阻塞，并且释放同步监视器
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

面试题：
1、wait和notify和notifyAll
wait：阻塞并释放同步监视器
notify：唤醒被wait的一个线程；若有多个线程，则唤醒高优先级的一个
notifyAll：唤醒所有被wait的线程
注意：
wait、notify、notifyAll必须定义在同步代码块或同步方法中，
wait、notify、notifyAll的调用者必须是同步代码块或同步方法中的同步监视器**
wait、notify、notifyAll定义在java.lang.Object下
2、wait和sleep
共同：都会进入阻塞
不同：
wait必须定义在同步代码块或同步方法中，sleep任意位置；
wait定义在java.lang.Object下，sleep定义在Thread下
wait会释放同步监视器，sleep不会；
wait只有notify才会 不阻塞 ，sleep时间过了自动 不阻塞
**