JavaSE进阶29 - 线程调度概述、synchronized、面试题、死锁、守护线程、定时器、实现线程的第三种方式、wait和notify

线程调度概述（线程调度了解即可）

• 1.1、常见的线程调度模型有哪些？
  • 抢占式调度模型：
    • 哪个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
    • java采用的就是抢占式调度模型。
  • 均分式调度模型：
    • 平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
    • 平均分配，一切平等。
    • 有一些编程语言，线程调度模型采用的是这种方式。
• 1.2、java中提供了哪些方法是和线程调度有关系的呢？
  • 实例方法：
    • void setPriority(int newPriority) 设置线程优先级
    • int getPriority() 获取线程优先级
    • 最低优先级 1
    • 默认优先级 5
    • 最高优先级 10
    • 优先级比较高的获取CPU时间片可能会多一些。（大概率是的，但也不完全是。）
  • 静态方法：
    • static void yield() 让位方法
    • 暂停当前正在执行的线程对象，并执行其他线程
    • yield()方法不是阻塞方法，让当前线程让位，让给其他线程使用。
    • yiled()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
    • 注意，在回到就绪状态之后，有可能还会再次抢到。
  • 实例方法：

    • void join()

    • 合并线程

    • class MyThread1 extends Thread{
      public void doSome(){
      MyThread2 t = new MyThread2();
      t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续执行。
      }

      class MyThread2 extends Thread{
      }

线程优先级

package com.bjpowernode.javase.thread;

public class ThreadTest11 {
    
    
    public static void main(String[] args) {
    
    
        // 设置主线程的优先级为1
        Thread.currentThread().setPriority(1);

        /*System.out.println("最高优先级" + Thread.MAX_PRIORITY);
        System.out.println("最低优先级" + Thread.MIN_PRIORITY);
        System.out.println("默认优先级" + Thread.NORM_PRIORITY);*/

        // 获取当前线程对象，获取当前线程的优先级
        Thread currentThread = Thread.currentThread();
        // main线程的默认优先级是：5
        System.out.println(currentThread.getName() + "线程的默认优先级是：" + currentThread.getPriority());

        Thread t = new Thread(new MyRunnable5());
        // 设置t线程的优先级为10
        t.setPriority(10);
        t.setName("t");
        t.start();

        // 优先级较高的，只是抢到的时间片相对多一些。
        // 大概率方向会偏向优先级高的
        for(int i = 0; i < 1000; i ++){
    
    
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

class MyRunnable5 implements Runnable{
    
    
    @Override
    public void run() {
    
    
        // 获取线程优先级
        System.out.println(Thread.currentThread().getName() + "线程的默认优先级是：" + Thread.currentThread().getPriority());

        for(int i = 0; i < 1000; i ++){
    
    
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

线程让位

package com.bjpowernode.javase.thread;

/*
让位，当前线程暂停，回到就绪状态，让给其他线程。
静态方法：Thread.yield();
 */
public class ThreadTest12 {
    
    
    public static void main(String[] args) {
    
    

        Thread t = new Thread(new MyRunnable6());
        t.setName("t");
        t.start();

        for(int i = 1; i <= 1000; i ++){
    
    
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

class MyRunnable6 implements Runnable{
    
    
    @Override
    public void run() {
    
    
        for(int i = 1; i <= 1000; i ++){
    
    
            // 每100个让位一次
            if(i % 100 == 0){
    
    
                Thread.yield(); // 当前线程暂停一下，让给主线程。
            }
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

线程合并

package com.bjpowernode.javase.thread;

/*
线程合并
 */
public class ThreadTest13 {
    
    
    public static void main(String[] args) {
    
    
        System.out.println("main begin");

        Thread t = new Thread(new MyRunnable7());
        t.setName("t");
        t.start();

        // 合并线程
        try {
    
    
            t.join(); // t合并到当前线程中，当前线程受堵塞，t线程执行直到结束。
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }

        System.out.println("main end");
    }
}

class MyRunnable7 implements Runnable{
    
    
    @Override
    public void run() {
    
    
        for(int i = 0; i < 100; i ++){
    
    
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

多线程并发环境下，数据的安全问题

• 2.1、为什么这是重点
  • 以后的开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。
  • 最重要的是：你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。（重点：*****）
• 2.2、什么时候数据在多线程并发的环境下会存在安全问题呢？
  • 三个条件：
    • 条件1：多线程并发
    • 条件2：有共享数据
    • 条件3：共享数据有修改的行为
    • 满足以上三个条件之后，就会存在线程安全问题。
• 
• 2.3、怎么解决线程安全问题呢？
  • 当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
    • 线程排队执行。（不能并发）
    • 用排队执行解决线程安全问题。
    • 这种机制被称为：线程同步机制。
    • 专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。
  • 怎么解决线程安全问题呀？
    • 使用“线程同步机制”。
  • 线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。
• 2.4、说到线程同步这块，涉及到两个专业术语：
  • 异步编程模型：
    • 线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。
    • 其实就是：多线程并发（效率较高）。
    • 异步就是并发。
  • 同步编程模型：
    • 线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。线程排队执行。
    • 同步就是排队。

模拟两个线程对同一个账户取款

package com.bjpowernode.javase.threadsafe;

public class Account {
    
    
    // 账号
    private String actno;
    // 余额
    private double balance;

    public Account() {
    
    
    }

    public Account(String actno, double balance) {
    
    
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
    
    
        return actno;
    }

    public void setActno(String actno) {
    
    
        this.actno = actno;
    }

    public double getBalance() {
    
    
        return balance;
    }

    public void setBalance(double balance) {
    
    
        this.balance = balance;
    }

    // 取款的方法
    public void withdraw(double money){
    
    
        // t1和t2并发这个方法。。。。（t1和t2是两个栈。两个栈操作堆中同一个对象。)
        // 取款之前的余额
        double before = this.getBalance();
        // 取款之后的余额
        double after = before - money;

        // 在这里模拟下网络延迟，100%会出现问题
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }

        // 更新余额
        // 思考：t1执行到这里了，但还没有来得及执行这行代码，t2线程进来withdraw方法了。此时一定出问题。
        this.setBalance(after);
    }
}

package com.bjpowernode.javase.threadsafe;

/**
 * 银行账户
 *      不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题。
 */
public class AccountThread extends Thread{
    
    

    // 两个线程必须共享同一个账户对象
    private Account act;

    // 通过构造方法传递过来账户对象
    public AccountThread(Account act){
    
    
        this.act = act;
    }

    public void run(){
    
    
        // run方法的执行表示取款操作。
        // 假设取款5000
        double money = 5000;
        // 取款
        act.withdraw(money);
        System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功，余额" + act.getBalance());
    }
}

package com.bjpowernode.javase.threadsafe;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        // 创建账户对象（只创建一个）
        Account act = new Account("act-01", 10000);
        // 创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);
        // 设置name
        t1.setName("t1");
        t2.setName("t2");
        // 启动线程取款
        t1.start();
        t2.start();
    }
}

同步代码块synchronized

package com.bjpowernode.javase.threadsafe2;

public class Account {
    
    
    // 账号
    private String actno;
    // 余额
    private double balance;

    public Account() {
    
    
    }

    public Account(String actno, double balance) {
    
    
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
    
    
        return actno;
    }

    public void setActno(String actno) {
    
    
        this.actno = actno;
    }

    public double getBalance() {
    
    
        return balance;
    }

    public void setBalance(double balance) {
    
    
        this.balance = balance;
    }

    // 取款的方法
    public void withdraw(double money){
    
    
        // 以下这几行代码必须是线程排队的，不能并发。
        // 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
        /*
        线程同步机制的语法是：
            synchronized(){
                // 线程同步代码块。
            }
            synchronized后面小括号中传的这个“数据”是相当关键的。
            这个数据必须是多线程共享的数据。才能达到多线程排队的效果。

            ()中写什么？
                那要看你想让哪些线程同步。
                假设t1、t2、t3、t4、t5，有5个线程，
                你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？
                你一定要()中写一个t1 t2 t3共享的对象，而这个
                对象对于t4 t5来说不是共享的。

            这里的共享对象是：账户对象。
            账户对象是共享的，那么this就是共享的。
            不一定是this，这里只要是多线程共享的那个对象就行。

            在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁。）
            100个对象，100把锁。1个对象1把锁。

            以下代码的执行原理？
                1、假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
                2、假设t1先执行了，遇到了synchronized，这个时候自动找“后面共享对象”的对象锁，
                找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占
                有这把锁的。直到同步代码块结束，这把锁才会释放。
                3、假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会占有后面共享对象
                的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，直到t1把同步
                代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后，
                进入同步代码块执行程序。

                这样就达到了线程排队执行。
                这里需要注意的是：这个共享对象一定要选好了。这个共享对象一定是你需要排队执行的这
                些线程对象所共享的。
        */
        synchronized(this){
    
    
            double before = this.getBalance();
            double after = before - money;
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }
}

synchronized理解

package com.bjpowernode.javase.threadsafe2;

public class Account {
    
    
    // 账号
    private String actno;
    // 余额
    private double balance;
    // 对象
    Object obj = new Object(); // 实例变量。
    // Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。

    public Account() {
    
    
    }

    public Account(String actno, double balance) {
    
    
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
    
    
        return actno;
    }

    public void setActno(String actno) {
    
    
        this.actno = actno;
    }

    public double getBalance() {
    
    
        return balance;
    }

    public void setBalance(double balance) {
    
    
        this.balance = balance;
    }

    // 取款的方法
    public void withdraw(double money){
    
    
        // 以下这几行代码必须是线程排队的，不能并发。
        // 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
        /*
            线程同步机制的语法是：
            synchronized(){
                // 线程同步代码块。
            }
            synchronized后面小括号中传的这个“数据”是相当关键的。
            这个数据必须是多线程共享的数据。才能达到多线程排队的效果。

            ()中写什么？
                那要看你想让哪些线程同步。
                假设t1、t2、t3、t4、t5，有5个线程，
                你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？
                你一定要()中写一个t1 t2 t3共享的对象，而这个
                对象对于t4 t5来说不是共享的。

            这里的共享对象是：账户对象。
            账户对象是共享的，那么this就是共享的。
            不一定是this，这里只要是多线程共享的那个对象就行。

            在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁。）
            100个对象，100把锁。1个对象1把锁。

            以下代码的执行原理？
                1、假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
                2、假设t1先执行了，遇到了synchronized，这个时候自动找“后面共享对象”的对象锁，
                找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占
                有这把锁的。直到同步代码块结束，这把锁才会释放。
                3、假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会占有后面共享对象
                的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，直到t1把同步
                代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后，
                进入同步代码块执行程序。

                这样就达到了线程排队执行。
                这里需要注意的是：这个共享对象一定要选好了。这个共享对象一定是你需要排队执行的这
                些线程对象所共享的。
        */
        Object obj2 = new Object();
        synchronized(this){
    
    
        //synchronized(obj){ // 可以，Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。
        //synchronized(obj2){ // 这样编写就不安全了。因为obj2不是共享对象。
        //synchronized ("abc"){ // "abc"在字符串常量池当中。可以，但是所有线程都会同步，t1 t2 t3 t4 t5线程都会同步。
//        Object o = null;
//        synchronized (o){
    
    
            double before = this.getBalance();
            double after = before - money;
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }
}

哪些变量有线程安全问题

• 实例变量：在堆中。
• 静态变量：在方法区。
• 局部变量：在栈中。
• 以上三大变量中：
  • 局部变量永远都不会存在线程安全问题。
  • 因为局部变量不共享。（一个线程一个栈）
  • 局部变量在栈中。所以局部变量永远都不会共享。
• 实例变量在堆中，堆只有1个。
• 静态变量在方法区中，方法区只有1个。
• 堆和方法区都是多线程共享的，所以可能存在线程安全问题。
• 常量不会有线程安全问题，因为常量不可修改。

扩大synchronized范围

• 取消withdraw()中的synchronized

//        synchronized (o){
    
    
            double before = this.getBalance();
            double after = before - money;
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            this.setBalance(after);
        //}

• 重写run()方法，增加synchronized

public void run(){
    
    
        // run方法的执行表示取款操作。
        // 假设取款5000
        double money = 5000;
        // 取款
        //synchronized (this){ // this不是共享对象，this指的是线程对象，非账户对象
        synchronized(act){
    
    
            act.withdraw(money);
        }
        System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功，余额" + act.getBalance());
    }

synchronized出现在实例方法中

// 取款的方法
    /**
     * 在实例方法上可以使用synchronized吗？可以
     * synchronized出现在实例方法上，一定锁的是this。
     * 没得挑，只能是this。不是是其他对象。
     * 所以这种方式不灵活。
     *
     * 另外还有一个缺点：synchronized出现在实例方法上，
     * 表示整个方法体都需要同步，可能会无故扩大同步的范围，
     * 导致程序的执行效率降低。所以这种方式不常用。
     *
     * synchronized使用在实例方法上有什么优点？
     *      代码写的少了。节俭了。
     *
     * 如果共享的对象就是this，并且需要同步的代码块是整个方法体，
     * 建议使用这种方式。
     *
     * 如果使用局部变量的话：
     * 建议使用：StringBuilder。
     * 因为局部变量不存在线程安全问题。选择StringBuilder。
     * StringBuffer效率比较低。
     *
     * ArrayList是非线程安全的。
     * Vector是线程安全的。
     * HashMap HashSet是非线程安全的。
     * Hashtable是线程安全的。
     */
    public synchronized void withdraw(double money){
    
    
        double before = this.getBalance();
        double after = before - money;
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        this.setBalance(after);
    }

synchronized的三种写法

/**
synchronized有三种写法：
	第一种：同步代码块
		灵活
		synchronized(线程共享对象){
			同步代码块;
		}
	第二种：在实例方法上使用synchronized
		表示共享对象一定是this
		并且同步代码块是整个方法体。
	第三种：在静态方法上使用synchronized
		表示找类锁。
		类锁永远只有1把。
		就算创建了100个对象，那类锁也只有一把。
	对象锁：1个对象1把锁，100个对象100把锁。
	类锁：100个对象，也可能只是1把类锁。
*/

synchronized面试题1

package com.bjpowernode.javase.exam1;

// 面试题：doOther方法的执行需不需要等待doSome方法的结束？
// 不需要，因为doOther方法上没有synchronized，不需要排队
public class Exam01 {
    
    
    public static void main(String[] args) {
    
    
        MyClass mc = new MyClass();
        MyThread t1 = new MyThread(mc);
        MyThread t2 = new MyThread(mc);

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

        t1.start();
        try {
    
    
            Thread.sleep(1000); // 这个睡眠的作用是：为了保证t1线程先执行。
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        t2.start();
    }
}

class MyThread extends Thread{
    
    
    private MyClass mc;
    public MyThread(MyClass mc){
    
    
        this.mc = mc;
    }
    public void run(){
    
    
        if(Thread.currentThread().getName().equals("t1")){
    
    
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
    
    
            mc.doOther();
        }
    }
}

class MyClass{
    
    
    public synchronized void doSome(){
    
    
        System.out.println("doSome begin");
        try {
    
    
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public void doOther(){
    
    
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

synchronized面试题2

package com.bjpowernode.javase.exam2;

// 面试题：doOther方法的执行需不需要等待doSome方法的结束？
// 需要，doSome将this锁拿走了，mc对象只有一个，需要等待排队。
public class Exam02 {
    
    
    public static void main(String[] args) {
    
    
        MyClass mc = new MyClass();
        MyThread t1 = new MyThread(mc);
        MyThread t2 = new MyThread(mc);

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

        t1.start();
        try {
    
    
            Thread.sleep(1000); // 这个睡眠的作用是：为了保证t1线程先执行。
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        t2.start();
    }
}

class MyThread extends Thread{
    
    
    private MyClass mc;
    public MyThread(MyClass mc){
    
    
        this.mc = mc;
    }
    public void run(){
    
    
        if(Thread.currentThread().getName().equals("t1")){
    
    
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
    
    
            mc.doOther();
        }
    }
}

class MyClass{
    
    
    public synchronized void doSome(){
    
    
        System.out.println("doSome begin");
        try {
    
    
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public synchronized void doOther(){
    
    
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

synchronized面试题3

package com.bjpowernode.javase.exam3;

// 面试题：doOther方法的执行需不需要等待doSome方法的结束？
// 不需要，因为两种不同的对象锁，互不影响。
public class Exam03 {
    
    
    public static void main(String[] args) {
    
    
        MyClass mc1 = new MyClass();
        MyClass mc2= new MyClass();

        MyThread t1 = new MyThread(mc1);
        MyThread t2 = new MyThread(mc2);

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

        t1.start();
        try {
    
    
            Thread.sleep(1000); // 这个睡眠的作用是：为了保证t1线程先执行。
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        t2.start();
    }
}

class MyThread extends Thread{
    
    
    private MyClass mc;
    public MyThread(MyClass mc){
    
    
        this.mc = mc;
    }
    public void run(){
    
    
        if(Thread.currentThread().getName().equals("t1")){
    
    
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
    
    
            mc.doOther();
        }
    }
}

class MyClass{
    
    
    public synchronized void doSome(){
    
    
        System.out.println("doSome begin");
        try {
    
    
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public synchronized void doOther(){
    
    
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

synchronized面试题4

package com.bjpowernode.javase.exam4;

// 面试题：doOther方法的执行需不需要等待doSome方法的结束？
// 需要，因为静态方法是类锁，类锁不管创建了几个对象，类锁只有一把。
public class Exam04 {
    
    
    public static void main(String[] args) {
    
    
        MyClass mc1 = new MyClass();
        MyClass mc2= new MyClass();

        MyThread t1 = new MyThread(mc1);
        MyThread t2 = new MyThread(mc2);

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

        t1.start();
        try {
    
    
            Thread.sleep(1000); // 这个睡眠的作用是：为了保证t1线程先执行。
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        t2.start();
    }
}

class MyThread extends Thread{
    
    
    private MyClass mc;
    public MyThread(MyClass mc){
    
    
        this.mc = mc;
    }
    public void run(){
    
    
        if(Thread.currentThread().getName().equals("t1")){
    
    
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
    
    
            mc.doOther();
        }
    }
}

class MyClass{
    
    
    // synchronized出现在静态方法上是找类锁。
    public synchronized static void doSome(){
    
    
        System.out.println("doSome begin");
        try {
    
    
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public synchronized static void doOther(){
    
    
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

死锁概述

package com.bjpowernode.javase.deadlock;

/*
死锁代码要会写。
一般面试官要求你会写。
只有会写，才会在以后的开发中注意这个事儿。
因为死锁很难调试。
synchronized在开发中最好不要嵌套使用，容易发生死锁现象。
 */
public class DeadLock {
    
    
    public static void main(String[] args) {
    
    
        Object o1 = new Object();
        Object o2 = new Object();

        // t1，t2线程共享o1和o2
        Thread t1 = new MyThread1(o1, o2);
        Thread t2 = new MyThread2(o1, o2);

        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 MyThread2(Object o1, Object o2){
    
    
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
    
    
        synchronized (o2){
    
    
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            synchronized (o1){
    
    

            }
        }
    }
}

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

/*
是一上来就选择线程同步吗？synchronized
	不是，synchronized会让程序的执行效率降低，用户体验不好。
	系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
	线程同步机制。
第一种方案：
	尽量使用局部变量代替“实例变量和静态变量”
第二种方案：
	如果必须是实例变量，那么可以考虑创建多个对象，这样
	实例变量的内存就不共享了。（一个线程对应1个对象，
	100个线程对应100个对象，对象不共享，就没有数据安全
	问题了。）
第三种方案：
	如果不能使用局部变量，对象也不能创建多个，这个时候就
	只能选择synchronized了。线程同步机制。
*/

守护线程概述

/*
java语言中线程分为两大类：
	一类是：用户线程
	一类是：守护线程（后台线程）
	其中具有代表性的就是：垃圾回收线程（守护线程）
守护线程的特点是：
	一般守护线程是一个死循环，所有的用户线程只要结束，
	守护线程自动结束。
注意：主线程main方法是一个用户线程。
守护线程用在什么地方呢？
	每天00:00的时候系统数据自动备份。
	这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
	一直在那里看着，没到00:00的时候就备份一次。所有的用户线程
	如果结束了，守护线程自动退出，没有必要进行数据备份了。
*/

package com.bjpowernode.javase.thread;

/*
守护线程
 */
public class ThreadTest14 {
    
    
    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(Thread.currentThread().getName() + "--->" + 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方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行
		任务。这种方式是最原始的定时器。（比较low）
		
		在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。
		不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时
		任务的。
		
		在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，
		这个框架只要进行简单的配置，就可以完成定时器的任务。
*/

实现线程的第三种方式

/*
实现Callable接口。（JDK8新特性）
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
思考：
	系统委派一个线程去执行一个任务，该线程执行完任务之后，可能
	会有一个执行结果，我们怎么能拿到这个执行结果呢？
		使用第三种方式：实现Callable接口方式。
*/

package com.bjpowernode.javase.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask; // JUC包下的，属于java的并发包，老JDK中没有这个包。新特性。

/*
实现线程的第三种方式：
    实现Callable接口
    这种方式的优点：可以获取到线程的执行结果。
    这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率比较低。
 */
public class ThreadTest15 {
    
    
    public static void main(String[] args) throws Exception{
    
    

        // 第一步：创建一个“未来任务类”对象
        // 参数非常重要，需要给一个Callable接口实现类对象。
        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; // 自动装箱（300结果编程Integer）
            }
        });

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

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

        // 这里是main方法，这是在主线程中
        // 在主线程中，怎么获取t线程的返回结果
        // get()方法的执行会导致“当前线程堵塞”
        Object obj = task.get();
        System.out.println("线程的执行结果" + obj);

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

wait和notify的概述

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

第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象
都有的方法，因为这两个方式是Object类自带的。
	wait方法和notify方法不是通过线程对象调用，
	不是这样的：t.wait()，也不是这样的：t.notify()..不对。
	
第二：
	wait()方法作用？
	Object o = new Object();
	o.wait();	
	表示：
		让正在o对象上活动的线程进入等待状态，无期限等待，
		直到被唤醒为止。
		o.wait()方法的调用，会让“当前线程(正在o对象上
		活动的线程)”进入等待状态

第三：notify()方法作用？
	Object o = new Object();
	o.notify(;
	表示：
		唤醒正在o对象上等待的线程。
	还有一个notifyAll()方法：
		这个方法是唤醒o对象上处于等待的所有线程。
*/

生产者和消费者模式

package com.bjpowernode.javase.thread;

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

/**
 * 1、使用wait方法和notify方法实现“生产者和消费者模式”
 * 2、什么是“生产者和消费者模式”？
 *      生产线程负责生产，消费线程负责消费。
 *      生产线程和消费线程要达到均衡。
 *      这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。
 * 3、wait和notify方法不是线程对象的方法，是普通java对象都有的方法。
 * 4、wait和notify方法建立在线程同步的基础上。因为多线程要同时操作一个仓库。有线程安全问题。
 * 5、wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放t线程之前占有的o对象的锁。
 * 6、notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。
 * 7、模拟这样一个需求：
 *      仓库我们采用List集合。
 *      List集合中假设只能存储1个元素。
 *      1个元素就表示仓库满了。
 *      如果List集合的元素个数是0，就表示仓库空了。
 *      保证List集合中永远都是最多存储1个元素。
 *
 *      必须做到这种效果：生产1个消费1个
 */
public class ThreadTest16 {
    
    
    public static void main(String[] args) {
    
    
        // 创建1个仓库对象，共享的
        List list = new ArrayList();
        // 创建两个线程对象
        // 生产者线程
        Thread t1 = new Thread(new Producer(list));
        t1.setName("生产者线程");
        // 消费者线程
        Thread t2 = new Thread(new Consumer(list));
        t2.setName("消费者线程");

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

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

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

    public void run(){
    
    
        // 一直生产(使用死循环模拟一直生产)
        while(true){
    
    
            // 给仓库对象list加锁。
            synchronized (list){
    
    
                if(list.size() > 0){
    
     // 大于0说明仓库中已经有1个元素了。若仓库中存放10个元素，即生产10个，消费10个，可直接将>0换成>9即可。
                    // 当前线程进入等待状态，并且释放Producer之前占有的list集合的锁。
                    try {
    
    
                        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;
    }

    public void run(){
    
    
        // 一直消费
        while(true){
    
    
            synchronized (list){
    
    
                if(list.size() == 0){
    
     // 代表仓库已经空了。
                    // 消费者线程等待，释放掉list集合的锁。
                    try {
    
    
                        list.wait();
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }

                }
                // 程序能够执行到此处说明仓库中有数据，进行消费。
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "---->" + obj);
                // 唤醒生产者生产
                list.notify();
            }
        }
    }
}