多线程基础（一）线程基础信息、synchronized 锁概念

明湖起风了

已于 2023-05-28 19:03:59 修改

阅读量549

点赞数

分类专栏： Java并发编程文章标签： java

于 2023-05-20 21:31:39 首次发布

本文链接：https://blog.csdn.net/m0_47743175/article/details/130780368

版权

Java并发编程专栏收录该内容

19 篇文章 5 订阅

订阅专栏

1. 基本概念：

程序：

程序是一些保存在磁盘上的指令的有序集合，是静态的。程序包括：内存资源、IO资源、信号处理等。（如：XX.exe）

进程：

进程是程序执行的过程，包括了动态创建、调度和消亡的整个过程，进程是程序资源管理的最小单位。(当：XX.exe执行后，就会创建进程)

线程：

线程是操作操作系统能够进行运算调度的最小单位。线程被包含在进程之中，是进程中的实际运作单位，一个进程内可以包含多个线程，线程是资源调度的最小单位。

协程/纤程：

协程 Coroutines 是一种比线程更加轻量级的微线程。类比一个进程可以拥有多个线程，一个线程也可以拥有多个协程，因此协程又称微线程和纤程。

2. 线程的启动

public class theardTest {

    private static class T1 extends Thread{
        @Override
        public void run(){
            for (int i=0;i<10;i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("T1");
            }
        }
    }

    public static void main(String[] args) {
        new T1().run();
        // new T1().start();
        for (int i=0;i<10;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Main");
        }

    }

}

使用 new T1().run(); 执行结果：

T1
Main
Main
Main
Main
Main
Main
Main
Main
Main
Main

结论：使用 new T1().run(); 方式执行启动线程，会先执行 T1 中的方法，然后再执行主程序 Main方法。

使用 new T1().start(); 方式执行后：

Main
T1
T1
Main
T1
Main
Main
T1
Main
T1
Main

结论：使用 new T1().start(); T1 线程会和主线程抢占资源执行。

面试题：启动（实现）线程的三种方式：

1. 继承 Thread类
2. 实现 Runnable接口

3. 使用线程池。如： Executors.newCachedThreadPool();

3. 线程的基本方法

// 当前线程睡眠1000毫秒
Thread.sleep(1000);

// 当前线程回到等待队列，重新竞争cpu资源
Thread.yield();

// 当 T1线程执行完毕后，才开始执行当前线程
T1.join();

注意：T1.join() 方法可以确保线程执行的顺序。

4. 线程状态

new 新建状态 ——>start 进入线程 ——>runnable 可执行状态 ——>cpu选中 running 执行状态 ——>blocked 等待状态 ——> terminated 结束状态。

注：一般我们不用stop是停止线程。而是使用 intertupted方法去判断当前线程是否已经中断，去清除状态。

5. synchronized 锁

JVM规范里并没有说明synchronized必须要怎么实现，它只要给一个对象加上锁，才可以去执行锁里的代码，锁的是对象，不是代码。并且，锁定的方法和非锁定的方法会同时执行，这个要注意脏读问题。

并且 synchronized 是可以保证可见性、原子性、有序性的。

而 volatile不保证原子性，在开发中没有把握也不要用这个。使用 volatile 尽量去修饰简单的变量，不要修饰引用对象，如果引用对象中的成员变量修改了，volatile 是不会发现的。

synchronized 包括 monitor enter 获取监视器锁、monitor exi 释放监视器锁，这个重要JVM指令，java中每个对象都关联着一个监视器，当线程获取了某一对象的监视器锁，再次获取时，只增加对应的计数，不在重新执行一次获取过程。

这就是 synchronized 的可重入锁，比如：m1方法加了 synchronized ，在m1中调用m2，m2方法也是加了synchronized锁的，但是，m1可以正常调用m2方法。

即：一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，（调用其他方法时）再次申请锁的时候，仍然会得到该对象的锁，只增加对应的计数，这就是获得的锁是可重入的。

synchronized的锁升级

markword 记录这个线程ID(偏向锁)

如果线程争用:升级为自旋锁（轻量级锁）

10次以后，升级为重量级锁 - OS（向操作系统申请锁）

锁只能升不能降（锁膨胀）。执行时间短《加锁代码)，线程数少，用自旋，执行时间长，线程数多，用系统锁

使用锁的注意事项

1. 程序在执行过程中，如果出现异常，默认情况锁会被释放所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。比如，在一个web app处理过程中，多个servlet线程共同访网同一个资源，这时如果异常处理不合适在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据。因此要非常小心前处理同步业务逻超中的异常.

2. synchronized（Object）不能使用String常量、Integer、Long类型等基础数据类型。

3. 锁的细粒度和粗粒度

实际业务逻辑中，如果只有很少的代码（一行或者几行）需要加锁，则在这些代码上加锁，这就是采用细粒度的锁，可以使线程争用时向变短，从而提高效率。

// 业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
// 采用细粒度的锁，可以使线程争用时问变短，从而楚高效率
synchronized(this) {
    count++;
}

如果实际业务中，这个方法下有多个代码段都需要使用sync锁，则需要在该方法上加锁，使用粗粒度锁，避免频繁调用 sync锁。

4. 锁定某对象o，如果o的属性发生改变，不形响锁的使用但是如果o变成另外一个对象，则锁定的对象发生改变，应该避免将锁定对象的引用变成另外的对象。即：需要在该对象前加上 final 属性。