2022-08-03 第二小组 张明旭 Java基础学习记录

目录

心情日记

重点归纳

知识点 

锁

锁的性质

 同步

关于同步方法

 关于同步代码块

缺点 

 synchronized

火车站买票问题（继承Thread）

火车站买票问题（实现Runnable）

死锁

概念

 Java产生死锁的四大条件

线程重入

挂起线程

Object类对多线程的支持

线程间的通信

 

方法总结

面试题：sleep和wait的区别（周日考）

案例：生产者与消费者模型

包子铺问题

线程的退出

interrupt方法：中断线程。

线程的常用方法

懒汉式单例模式线程安全问题

---

心情日记

多线程名不虚传，难点真的多，所以思路要清晰，记住基本结构和如何创建方法。而且多线程部分会涉及一些专有名词概念，比较琐碎要记住。还有一件事：我考试考low了(╥ω╥`)  ，分低的有点不太能接受了，比平均分还低了几分，难受。

重点归纳

• 锁

• 多线程的退出

• 多线程中常用方法

知识点 

*多线程的代码具有不确定性，部分代码可能每一次运行都有不同结果，主要掌握概念及流程

锁

 synchronized 多线程并发编程
     重量级锁JDK1.6对synchronized进行了优化
     JDK4.6为了减少获得锁和释放锁带来的性能消耗引入偏向锁和轻量级锁

synchronized有三种方式加锁：
（1）修饰实例方法，作用于当前实例加锁，进入同步代码之前要获得当前实例的锁
（2）静态方法，作用于当前类对象加锁，进入同步代码前要获得的当前类对象的锁
（3）同步代码块，指定加锁对象，给指定的对象加锁，进入同步代码块之前要获得给定对象的锁

 锁的对象：
1.实例方法，调用该方法的实例
2.静态方法：类对象
（什么叫类对象？ --- Ch01.class）
3.this：调用该方法的实例
4.类对象：类对象

    public static void main(String[] args) {
        //同步代码块
        //（）里面可以是同步监视器、创建一个对象、类对象、当前实例（this）
        synchronized (Ch01.class){
            int a = 1;

        }
    }

 操作共享数据的代码
共享数据：多个线程共同操作的变量，都可以充当锁

锁的性质

当使用同步方法时，synchronized锁的东西是当前对象（this）
一个对象使用同步方法时其他对象不可使用

 同步

关于同步方法

1.同步方法依然会涉及到同步锁对象，不需要我们写出来
2.非静态的同步方法，同步锁就是this。
3.静态的同步方法，同步监视器就是类本身

 关于同步代码块

1.首先选好同步监视器（锁），推荐使用类对象，第三方对象，this
2.在实现接口创建的线程类中，同步代码快不可以用this来充当同步锁

缺点 

同步的方式能解决线程安全，但操作同步代码时，只有一个线程能够参与，其他线程要等待，相当于一个单线程的过程，效率低

 synchronized

synchronized只针对于当前的JVM（电脑虚拟机）可以解决线程安全的问题
 synchronized不可以跨JVM解决问题。（最大问题！）而现在都是集群操作(多JVM)
例如： 如果有多个来自不同JVM的微服务，synchronized只能解决一个JVM的线程安全，其他的无能为力

 synchronized虽然少用，但原理很重要！！！

火车站买票问题（继承Thread）

class Window3 extends Thread {
    private static int ticket = 100;

    private String name;

    public Window3(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        sell();
    }

    private synchronized void sell() {
        while(true) {
            if(ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(name + "卖票，剩余：" + ticket-- + "张！");
            }else {
                break;
            }
        }
    }
}
public class Ch03 {

    public static void main(String[] args) {
        Window3 w1 = new Window3("窗口一");
        Window3 w2 = new Window3("窗口二");


        w1.start();
        w2.start();
    }
}

火车站买票问题（实现Runnable）

class Window implements Runnable {

    private static int ticket = 100;

    private String name;

    //创建什么类型的锁都可以，只要保证所有方法用的同一个锁
    private static Object obj = new Object();

    public Window(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        synchronized (Window.class) {
            while(true) {
                if(ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(name + "卖票，剩余：" + ticket-- + "张！");
                }else {
                    break;
                }
            }
        }
    }
}

public class Demo {

    public static void main(String[] args) {
        Thread t1 = new Thread(new Window("窗口一"));
        Thread t2 = new Thread(new Window("窗口二"));

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

死锁

概念

死锁是一种情形，多个线程同时阻塞，它们中的一个或多个都在等待某个资源的释放，由于线程无限期的阻塞，程序就不可能正常终止

 Java产生死锁的四大条件

1.互斥使用：当一个资源被线程使用（占用），别的线程不能使用
2.不可抢占：资源请求者不能强制从占有者抢夺资源，资源只能从占有者手动释放
3.请求和保持：
4.循环等待，存在一个等待队列，p1占有p2的资源，p2占有p3的资源，p3占有p1的资源，形成一个等待环路。

class LockA implements Runnable {

    @Override
    public void run() {
        System.out.println(new Date().toString() + "LockA开始执行...");
        try {
            while (true) {
                synchronized (Demo.obj1) {
                    System.out.println(new Date().toString() + "LockA锁住了obj1");

                    Thread.sleep(8000);
                }
                synchronized (Demo.obj2) {
                    System.out.println(new Date().toString() + "LockA锁住了obj2");
                    Thread.sleep(70*1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class LockB implements Runnable {

    @Override
    public void run() {
        System.out.println(new Date().toString() + "LockB开始执行...");
        try {
            while (true) {
                synchronized (Demo.obj2) {
                    System.out.println(new Date().toString() + "LockB锁住了obj2");
                    Thread.sleep(6000); 
                }
                synchronized (Demo.obj1) {
                    System.out.println(new Date().toString() + "LockB锁住了obj1");
                    Thread.sleep(100*1000); 
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Demo {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";

    public static void main(String[] args) {
        LockA lockA = new LockA();
        new Thread(lockA).start();
        LockB lockB = new LockB();
        new Thread(lockB).start();
    }
}

线程重入

• 任意线程拿到锁之后，在此获取该锁不会被阻碍
• 线程不会被自己锁死
• 这就叫线程的重入，synchronized可重入锁

JDK1.6以后升级：
1.无锁：不加锁
2.偏向锁：不锁的锁，当只有一个线程争夺时，偏向某一个线程，这个线程不加锁
3.轻量级锁：少量线程来了之后，先尝试自旋。不挂起线程。
4.重量级锁：让你排队挂起（挂起科技所暂停，一会在执行）线程（synchronized）
（重量级锁多不用）

挂起线程

挂起线程和恢复线程需要转入内核态中完成操作，给系统的并发性发来很大压力
在许多应用上共享数据的锁定状态，只会持续很短的时间，为了这段时间去挂起和恢复并不值得
我们可以让后面的线程等待一下啊，不要放弃处理器的执行时间。
锁就是为了让线程等待，我们只需要让线程执行一个循环 ——自旋【自旋锁】

    private static final Object M1 = new Object();
    private static final Object M2 = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (M1) {
                synchronized (M2) {
                    synchronized (M1) {
                        synchronized (M2){
                            System.out.println("hello lock");
                        }
                    }
                }
            }
        }).start();
    }

Object类对多线程的支持

线程类提供的方法是Object类中的，不是抽象方法
1.wait（）：使线程进入等待状态
       使用时要抛异常
2.wait（long  timeout）：当前线程进入等待状态
3.notify（）：唤醒正在等待的下一个线程
       在一个线程中唤醒其他的线程
4.notifyAll（）：唤醒正在等待的所有线程
5.wait（）与notify（）搭配使用，开发中比较low，一般少用

线程间的通信

1.比如两条线成，共同运行。如果线程A先走，线程B就要等待，等待A线程唤醒B线程，B线程在走
2.唤醒和等待的前提是同步（synchronized）

//简单应用一下这几个方法
public class Ch01 {

    private static int num = 10;

    private static final Object OBJ = new Object();

    public static void plus(int code,int i) {
        synchronized (OBJ) {
            if(num >= 10){
                // 唤醒其他等待的线程
//               OBJ.notify();
                // 唤醒所有等待的线程
                OBJ.notifyAll();
            }
            System.out.println("这是线程" + code + "->" + ++num + "->" + i);
        }
    }
    public static void sub(int code,int i) {
        synchronized (OBJ) {
            if(num <= 0){
                try {
                    // 减法上来就是等待的状态
                    OBJ.wait(200);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("这是线程" + code + "->" + --num + "->" + i);
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0;; i++) {
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sub(1,i);
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0;; i++) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                plus(2,i);
            }
        });
        t1.start();
        t2.start();

        System.out.println("--------------------------------------------------");
    }
}

 

方法总结

1.Thread类的两个静态方法：
    sleep方法释放CPU资源，但是不会释放锁
    yield方法释放CPU执行权，保留了CPU的执行资格，不常用

2.join方法（插队），yield出让了执行权，join就加入进来。

3.wait方法：释放CPU资源，同时释放锁（Object类中的）
4.notify：唤醒等待中的线程
   notifyAll：唤醒等待中的所有线程

面试题：sleep和wait的区别（周日考）

1.sleep（）是Thread类中的方法；wait（）是Object类中的方法
2.sleep方法释放CPU资源，但是不会释放锁；释放CPU资源，同时释放锁
3.sleep（）是计时等待，指定时间过后继续执行线程；wait（）是永久等待，需要notify（）唤醒。

案例：生产者与消费者模型

两条线程：一条线程生产产品，另一条线程消费产品（消费者）
思路：
这两条线程，初始状态是什么情况？

包子铺问题

1.一个线程包包子，一个线程顾客吃包子

2.刚开始没有包子，顾客为等待状态，包子铺开始包包子，包子包完唤醒顾客开始吃，包子铺变成了等待状态，以此循环（假设包一个吃一个）

代码如下：

class MyBaoZiPu{
    private String pi;
    private String xian;
    private volatile boolean flag = true;

    public MyBaoZiPu() {
    }

    public MyBaoZiPu(String pi, String xian) {
        this.pi = pi;
        this.xian = xian;
    }

    synchronized void productBaoZi(String pi,String xian){
        if (!flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("包子铺开始做包子");
        System.out.println("包子做好了" + pi + xian);
        flag = false;
        notifyAll();
    }

    synchronized void customer(String pi,String xian){
        if (flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("吃货正在吃包子" + pi + xian);
        System.out.println("====================");
        flag = true;
        notifyAll();
    }
}

public class Baozi {
    public static void main(String[] args) {
        MyBaoZiPu myBaoZiPu = new MyBaoZiPu("薄皮","牛肉");
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    myBaoZiPu.productBaoZi("薄皮", "牛肉");
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    myBaoZiPu.customer("薄皮", "牛肉");
                }
            }
        }).start();
    }

线程的退出

• 使用推出标志，线程正常退出，run方法结束后线程终止
• stop（）线程停止进行（过时了，不用）

class MyThread extends Thread {

    volatile boolean flag = true;

    @Override
 //用while（true）循环线程
    public void run() {
        while(flag) {
            try {
                System.out.println("线程一直在运行...");
                int i = 10 / 0;
            } catch (Exception e) {
                this.stopThread();
            }
        }
    }
    //建立停止方法，用volatile可见性将true改成false,从而控制循环停止
    public void stopThread() {
        System.out.println("线程停止运行...");
        this.flag = false;
    }
}

public class Ch03 {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

interrupt方法：中断线程。

• wait（）或者sleep（）可以抛InterruptedException异常
•  调用interrupt方法会抛出InterruptedException异常，捕获后再做停止线程的逻辑即可。
• 如果线程while(true)运行的状态，interrupt方法无法中断线程。
• 挂起的程序能捕获到，不用volatile可见

class MyThread02 extends Thread {

    private boolean flag = true;

    @Override
    public void run() {
        while(flag) {
            synchronized (this){

                try {
                    sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    this.stopThread();
                }
            }
        }
    }
    public void stopThread() {
        System.out.println("线程停止运行...");
        this.flag = false;
    }
}
public class Ch04 {


    public static void main(String[] args) {
        MyThread02 myThread02 = new MyThread02();
        myThread02.start();

        System.out.println("线程开始...");

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 中断线程的执行
        myThread02.interrupt();
    }
}

线程的常用方法

Thread类中的方法
  1.start（）：启动当前线程；执行run方法
  2.run（）：
  3.currentThread（）：静态方法，获取当前正在执行的线程
  4.getId（）：返回此线程的唯一标识
  5.setName（）：设置当前线程的name
  6.getName（）：获取当前线程的name
  7.getPriority（）：获取当前线程的优先级
  8.setPriority（int）：设置当前线程的优先级
  9.getState（）：获取当前线程的生命周期
  10.interrupt（）：中断当前线程
  11.interrupted（）：测试当前线程是否中断（静态的）
  12.isInterrupted（）：测试当前线程是否中断
  13.sleep（String）：使线程休眠（单位毫秒）

volatile：表示不能重排，声明的对象存在内存中，循环使用时可见

class MyThread03 extends Thread {

    @Override
    public void run() {
        System.out.println(getId());
        setName("线程一");
        System.out.println(getName());
    }
}

public class Ch05 {

    public static void main(String[] args) {
//        Thread thread = Thread.currentThread();
//        System.out.println(thread);
        // 如何获取主线程的优先级
//        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        MyThread03 myThread03 = new MyThread03();
//        myThread03.setPriority(Thread.MAX_PRIORITY);
        myThread03.setDaemon(true);
        myThread03.start();

//        System.out.println(myThread03.getState());
        System.out.println(myThread03.isDaemon());
//        System.out.println("主" + Thread.currentThread().getPriority());
//        System.out.println("自己的：" + myThread03.getPriority());
//        new MyThread03().start();
//        new MyThread03().start();
    }
}

懒汉式单例模式线程安全问题

懒汉式最终版，效率安全都行，但还是过时
推荐使用内部类懒汉式或枚举，尽量使用枚举

枚举天生构造器私有化，适合做单例模式
枚举类中不能写public

//懒汉最终版
class Singleton {
    private static Singleton instant;

    private Singleton(){}

    public static Singleton getInstance() {
        if(instant == null) {
            // 卡了
            synchronized (Singleton.class) {
                if(instant == null){
                    instant = new Singleton();
                }
            }
        }
        return instant;
    }
}

public class Ch06 {

    public static void main(String[] args) {
        System.out.println(Singleton.getInstance() == Singleton.getInstance());
    }
}