2022/08/02 学习笔记 （day22） 多线程

 

目录

多线程： 

          1.创建线程：

   （1）继承Thread类：

   （2）Runnable接口（推荐使用）：

          2.Thread和Runnable的区别:

          3.线程的生命周期:

          4.CPU多核缓存结构:

 5.线程安全的实现方法:

线程状态转换：

---

多线程： 

1.创建线程：

  （1）继承Thread类：

      Thread类中的run方法不是抽象方法，Thread类也不是抽象类

      MyThread当继承了Thread类之后，它就是一个独立的线程。

      要让线程启动。调用线程的start方法。 
 

class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println(2);
    }
}

public class Ch01 {

    public static void main(String[] args) {
        System.out.println(1);
        //
        MyThread myThread = new MyThread();
        // 当调用start方法启动一个线程时，会执行重写的run方法的代码
        // 调用的是start，执行的是run，为什么不直接调run
        myThread.start();
        // 普通的对象调方法
//        myThread.run();

        // 线程的优先级，概率问题！做不到百分百
        // 90会先跑主方法 10先跑mythread

        System.out.println(3);
        System.out.println(4);
    }
}

   （2）Runnable接口（推荐使用）：

class MyThread2 implements Runnable {

    @Override
    public void run() {
        System.out.println(2);
    }
}

public class Ch02 {

    public static void main(String[] args) {
        System.out.println(1);
//        start
        MyThread2 myThread2 = new MyThread2();
        // 如果想要让线程启动，必须调用Thread类中的start方法
        // 问题：实现了Runnable接口，找不到start方法了？

        Thread t = new Thread(myThread2);
        t.start();

        System.out.println(3);
        System.out.println(4);
    }
}

2.Thread和Runnable的区别:

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

3.线程的生命周期:

RUNNABLE：	线程正在JVM中被执行，等待来自操作系统的调度
NEW：	这个状态主要是线程未被start()调用执行
BLOCKED：	阻塞。因为某些原因不能立即执行需要挂起等待
WAITING：	无限期等待。Object类。如果没有唤醒，则一直等待
TIMED_WAITING：	有限期等待，线程等待一个指定的时间
TERMINATED：	终止线程的状态，线程已经执行完毕

​​​​​​
等待和阻塞两个概念有点像，阻塞因为外部原因，需要等待，
而等待一般是主动调用方法，发起主动的等待。等待还可以传入参数确定等待时间。

4.CPU多核缓存结构:

 物理内存：硬盘内存。（固态硬盘，尽量不要选择混合硬盘）

 CPU缓存为了提高程序运行的性能，现在CPU在很多方面对程序进行优化。
 CPU处理速度最快，内存次之，硬盘速度最低。
 在CPU处理内存数据时，如果内存运行速度太慢，就会拖累CPU的速度
 为了解决这样的问题，CPU设计了多级缓存策略。

 CPU分为三级缓存：每个CPU都有L1，L2缓存，但是L3缓存是多核公用的。

 CPU查找数据时，CPU->l1->l2->l3->内存->硬盘

 从CPU到内存，60-80纳秒
 从CPU到L3，15纳秒
 从CPU到L2，3纳秒
 从CPU到L1，1纳秒
 寄存器，0.3纳秒

 进一步优化，CPU每次读取一个数据，读取的时与它相邻的64个字节的数据。
 【缓存行】。

 英特尔提出了一个协议MESI协议
 1、修改态，此缓存被动过，内容与主内存中不同，为此缓存专有
 2、专有态，此缓存与主内存一致，但是其他CPU中没有
 3、共享态，此缓存与主内存一致，其他的缓存也有
 4、无效态，此缓存无效，需要从主内存中重新读取


 java内存模型-JMM
 尽量做到硬件和操作系统之间达到一致的访问效果。

 线程争抢:
 解决线程争抢的问题最好的办法就是【加锁】

 synchronized同步锁，线程同步

 当一个方法加上了synchronized修饰，这个方法就叫做同步方法。

 5.线程安全的实现方法:

（1）数据不可变。 一切不可变的对象一定是线程安全的。 对象的方法的实现方法的调用者，不需要再进行任何的线程安全的保障措施。 比如final关键字修饰的基本数据类型，字符串。 只要一个不可变的对象被正确的创建出来，那外部的可见状态永远都不会改变。

（2）互斥同步。加锁。【悲观锁】

（3）非阻塞同步。【无锁编程】，自旋。我们会用cas来实现这种非阻塞同步。

（4）无同步方案。多个线程需要共享数据，但是这些数据又可以在单独的线程中计算，得出结果 我们可以把共享数据的可见范围限制在一个线程之内，这样就无需同步。把共享的数据拿过来， 我用我的，你用你的，从而保证线程安全。

public class Ch02 {

    private static int x = 0,y = 0;
    private static int a = 0,b = 0;
    private static int count = 0;

    private volatile static int NUM = 1;

    public static void main(String[] args) throws InterruptedException {
        long start = System.currentTimeMillis();
        for (;;) {
            Thread t1 = new Thread(() -> {
                a = 1;
                x = b;
            });
            Thread t2 = new Thread(() -> {
                b = 1;
                y = a;
            });
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println("一共执行了：" + count++ + "次");
            if(x == 0 && y ==0){
                long end = System.currentTimeMillis();
                System.out.println("耗时：" +(end - start) + "毫秒，（" + x + "," + y + "）");
                break;
            }
            a = 0;b = 0;x = 0;y = 0;
        }
    }

         我们发现测试结果中大部分感觉是正确的，（0,1）或（1,0），一个是线程1先执行，一个是线程2先执行。 按道理来说，绝对不会出现（0,0），如果出现（0,0）代表存在指令重排，乱序执行。 使用volatile关键字来保证一个变量在一次读写操作时，避免指令重排。 我们在读写操作之前加入一条指令，当CPU碰到这条指令后必须等到前面的执行执行完成才能继续执行下一条指令。 

线程状态转换：