Java中的三大变量:

    实例变量：在堆中
    静态变量：在方法区中
    局部变量：在栈中

以上三大变量中：
        局部变量永远都不会存在线程安全问题
        因为局部变量不共享（一个线程一个栈）
        局部变量在栈中，所以局部变量永远都不会共享

实例变量在堆中，堆只有一个
    静态变量在方法区中，方法区只有一个
    堆和方法区都是多线程共享的，所以可能存在线程安全问题

synchronized三种写法：

　　 第一种：同步代码块

synchronized(线程共享对象){
                    同步代码块
}

　　第二种：在实例方法上使用synchronized
                表示共享对象一定是this
                并且同步代码块是整个方法体

　　第三种：在静态方法上使用synchronized
                表示找类所
                类所永远只有一把
                就算创建了一百个对象，类锁也只有一把

以后在开发中应该怎么解决线程安全问题

    使用synchronized会让程序执行效率降低，用户体验不好
    系统的用户吞吐量降低，用户体验差，不得已的情况下再使用
    线程同步机制

 　第一种方案：尽量使用局部变量代替“实例变量和静态变量”

    第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样
    实例变量的内存就不共享了，（一个线程对应一个对象，一把个线程对应一百个对象，
    对象不共享，就没有数据安全问题了）

    第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能
    选择synchronized了，线程同步机制

守护线程

    java语言中线程分为两大类：
        一类是:用户线程
        一类是：守护线程（后台线程）
        其中具有代表性的就是：垃圾回收线程（守护线程）
    
    守护线程的特点：
        一般守护线程是一个死循环，所有的用户线程只要结束。
        守护线程自动结束

    注意：主线程main是一个用户线程

守护线程用在什么地方呢？
        每天00:00的时候系统数据自动备份
        这个需要使用到定时器，并且我们可以将定时器设置为守护线程
        一直在那里看着，每到00:00的时候就备份一次，所以的用户线程
        如果结束了，守护线程自动退出，没有必要进行数据备份了

    public static void main(String[] args) {

        Thread t= new BakDataThread();
        t.setName("备份线程-->");

        // 启动线程之前，将线程设置为守护线程
        t.setDaemon(true);

        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main--->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class BakDataThread  extends  Thread{
    public void run(){

        int i = 0;
        // 即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止
        while(true){
            System.out.println(Thread.currentThread().getName()  +  ++i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

定时器
    定时器的作用：
        间隔特定的时间，去执行特定的程序

        在实际开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
        那么在java中有很多方法可以实现：

            可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行
            任务，这种方式是最原始的定时器

            在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用
            不过这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时
            任务的

            在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，
            这个框架只要进行简单的配置，就可以完成定时器的任务

public static void main(String[] args) {

        // 创建定时器对象
        Timer timer = new Timer();
        // Timer timer1 = new Timer(true);// 守护线程的方式

        // 指定定时任务
        // timer.schedule();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date firstDate = sdf.parse("2021-8-26 14:40:00");
            // 匿名内部类
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String strDate = sdf.format(new Date());
                    System.out.println(strDate + "完成了一次数据备份");
                }
            }, firstDate, 1000 * 10);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

// 编写一个定时任务类
// 假设这是一个记录日志的定时任务
/*
class LogTimerTask extends TimerTask {

    @Override
    public void run() {
        // 编写你需要执行的任务
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strTime = sdf.format(new Date());
        System.out.println(strTime + ":完成了一次数据备份");
    }
}
*/

实现线程的第三种方式：实现Callable接口（JDK8新特性）
    这种方式实现的线程可以获取线程的返回值
    前两种无法获取返回值，run返回void

    public static void main(String[] args) {
        // 第一步：创建一个“未来任务”类对象
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception { // call()方法就相当于run方法，只不过这个有返回值
                // 线程执行一个任务，执行之后可能会有一个执行结果
                // 模拟执行
                System.out.println("call method begin");
                Thread.sleep(1000 * 10);
                System.out.println("call method end");
                int a = 100;
                int b = 200;
                return a + b; // 自动 装箱（变成Integer）
            }
        });

        // 创建线程对象
        Thread t = new Thread(task);

        //启动线程
        t.start();

        // 这里是main()方法，这是在主线程中
        // 在主线程中，怎么获取t线程的返回结果呢？
        try {
            // get()方法的执行会导致当前线程阻塞
            Object obj = task.get();
            System.out.println("线程执行结果--->" + obj);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        // main方法这里的程序想要执行必须等待get()方法结束
        // 而get()方法可能需要执行很久。因为get()方法是为了拿到另一个线程的结果
        // 另一个线程执行是需要时间的
        System.out.println("hello jack");
    }
}

死锁：

    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        Thread t1 = new MyThread1(o1,o2);
        Thread t2 = new MyThread2(o1,o2);

        t1.setName("t1");
        t2.setName("t2");

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

class MyThread1 extends Thread{
    Object o1;
    Object o2;

    public MyThread1(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    public void run(){
        synchronized(o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(o2){

            }
        }
    }
}

class MyThread2 extends Thread{

    Object o1;
    Object o2;

    public void run(){
        synchronized(o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(o1){

            }
        }
    }

    public MyThread2(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
}

关于Object类中的wait和notify方法（生产者和消费者模式）

    第一：wait和notify方法不是线程对象的方法，是java中任何一个Java对象
    都有的方法，因为这两个方式是Object类中自带的
        wait and notify 方法不是通过线程对象调用的
    
    第二：wait()方法作用？
        Object o = new Object();
        o.wait();

        表示：
            让正在o对象上活动的线程进入等待状态，无期限等待，
            直到被唤醒为止
            o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态

    第三：notify()方法作用
        Object o = new Object();
        o.notify();

        表示：
            唤醒正在o对象上等待的线程
        
        还有一个notifyAll()方法：
            这个方法是唤醒o对象上处于等待的所有线程

package com.cedric.java.thread;

import java.util.ArrayList;
import java.util.List;

/*
1.使用wait()和notify方法实现“生产者和消费者模式”

2.什么是“生产者和消费者模式”？
      生产线程负责生产，消费线程负责消费
      生产线程和消费线程要达到均衡
      这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法、

3.wait方法和notify方法建立在线程同步的基础之上，因为多线程要同时操作一个仓库，有线程安全问题

4.wait方法作用：o.wait()让正在o对象上获取的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁

5.notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占用的锁

6.模拟这样一个需求：
    仓库采用List集合
    List集合中假设 只能存储一个元素
    1个元素就表示仓库满了
    如果List集合中元素个数是0，就表示仓库空了
    保证List集合中永远都是最多存储一个元素

    必须做到这种效果：生产一个消费一个
 */
public class ThreadTest15 {
    public static void main(String[] args) {
        // 创建一个仓库对象，共享的
        List list = new ArrayList();
        // 创建两个线程对象
        // 生产者线程
        Thread t1 = new Thread(new Producer(list));
        // 消费者线程
        Thread t2 = new Thread(new Consumer(list));

        t1.setName("生产者线程：");
        t2.setName("消费者线程：");

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

// 生产线程
class Producer implements Runnable{
    // 仓库
    private List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        // 一直生产(使用死循环来模拟一直生产)
        while(true){
            // 给仓库对象list加锁
            synchronized(list){
                if(list.size() > 0){ // 大于0，说明仓库中已经有一个元素了
                    try {
                        // 当前线程进入等待状态，并且释放Producer之前占有的list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 程序能够到这里说明仓库是空的，可以生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                // 唤醒消费者消费
                list.notify();

            }
        }
    }
}

// 消费线程
class Consumer implements Runnable{
    // 仓库
    private List list;

    public Consumer(List list) {
        this.list = list;
    }
    @Override
    public void run() {
        // 一直消费
        while(true){
            synchronized (list){
                if(list.size() == 0){
                    try {
                        // 仓库已经空了
                        // 消费线程等待，释放掉list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 程序能够执行到此处说明仓库中有数据，进行消费
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                // 唤醒生产者生产
                list.notify();
            }
        }
    }
}