对于多线程 & 锁的浅浅理解

Penguin_Luz

已于 2023-03-18 17:16:10 修改

阅读量883

点赞数 2

文章标签： java

于 2022-11-10 17:30:16 首次发布

本文链接：https://blog.csdn.net/penguin_J/article/details/127792091

版权

本文深入探讨Java中的多线程概念，包括线程调度、Thread类、Runnable接口、Callable接口、线程池、线程安全以及Synchronized同步锁和Lock手动锁的使用。此外，还详细介绍了死锁、线程通信以及wait、sleep、notify和notifyall等方法的比较。

摘要由CSDN通过智能技术生成

八、Callable和Runnable的区别

九、线程安全

十、Synchronized 同步锁 / 互斥锁

1.同步代码块：在代码块前加上synchronized关键字的代码块

2.同步方法：有synchronized关键字修饰的方法

3.加锁方式三：tryLock(long time,TimeUnit unit)

十三、Lock和Synchronized比较

一、相关概念

（1）程序：程序指的是为完成某种任务，用某种语言编写的一组指令的集合。

（2）进程：进程指的是程序的一次执行过程，或者是正在运行的一个程序，也就是说当一个程序被运行，就开启了一个进程。

（3）线程：进程可以进一步细化为线程，是一个程序内部执行的一条路径，也就是说一个进程可以有多个线程。

（4）并行：多个 cpu 同时执行多个任务。

（5）并发：一个 cpu 同时执行多个任务。

二、线程

1.线程的调度模式

cpu会给线程分配时间片，一旦得到了时间片，它就可以执行。抢到时间片的线程执行，没抢到时间片的线程继续处于就绪阶段。

2.线程的生命周期

三、Thread类

1.创建多线程

class 类名 extends Thread{

         //重写父类Thread中的run方法

        public void run(){

                线程要执行的任务（放在该方法中）

        }

}

public static void main(String[] args) {

        类名对象名 = new 类名();

        对象名.start;

}

class MyThread extends Thread {
    //run方法里面的就是线程需要执行的任务
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            //Thread类提供了一个静态方法getName()用于获取线程名称
            System.out.print(getName() + "线程打印---" + i + " ");
            //Thread-0线程打印---0 Thread-0线程打印---1 Thread-0线程打印---2 Thread-0线程打印---3 Thread-0线程打印---4 
        }
    }
}

public class ThreadCreate {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        //此处注意Thread中start方法和run方法的区别
        myThread.start();
        myThread.run();
        for (int i = 0; i < 5; i++) {
            System.out.print(Thread.currentThread().getName() + "线程打印---" + i + " ");
            //main线程打印---0 main线程打印---1 main线程打印---2 main线程打印---3 main线程打印---4  
        }
    }
}

Thread中start方法和run方法的区别：

start（）方法：启动一个线程，这时此线程 处于就绪状态，并没有真正的运行。一旦线程得到cpu时间片，就让线程开始执行run ()方法，run方法运行结束，此线程随即终止。

run（）方法：run方法相当于线程的任务处理逻辑的入口方法，就是线程体，它由JVM在运行相应线程时直接调用，而不是由代码进行调用。

2.Thread类的常用方法

start( )：启动当前线程调用线程中的 run 方法
run( )：通常需要重写 Thread 类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread( )：静态方法，返回执行当前代码的线程
getName( )：获取当前线程的名字
setName( )：设置当前线程的名字
interrupt( )：中断当前线程
interrupted( )：测试当前线程是否中断
isAlive( )：判断当前线程是否存活
join( )：在线程中插入执行另一个线程，该线程被阻塞，直到插入执行的线程完全执行完毕以后，该线程才继续执行下去
sleep（long millitime）：线程休眠一段时间
yield( )：主动释放当前线程的执行权

3.join方法：插队

//主线程与分线程抢时间片
public class ThreadJoin {
    public static void main(String[] args) throws InterruptedException {
        
        MyThread myThread = new MyThread();     //主线程
        myThread.start();   //开启分线程
        for (int i = 0; i < 10; i++) {   //主线程【抢时间片
            if (i == 4){
                //当main线程中i==4时，myThread线程开始插队，直到myThread线程执行完毕，main线程才重新获取时间碎片
                myThread.join();
            }
            System.out.println(Thread.currentThread().getName() + "-------" + i);
        }
        
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {   //分线程【抢时间片
            System.out.println(getName() + "--------" + i);
        }
    }
}

//利用join方法将线程进行“排队”，按顺序执行
public class ThreadJoin2 {
    public static void main(String[] args) throws InterruptedException {
        ABC t1 = new ABC("线程1");
        ABC t2 = new ABC("线程2");
        ABC t3 = new ABC("线程3");

        t1.start();
        t1.join();      //将t1插队到第一个获得时间碎片，进行执行

        t2.start();
        t2.join();      //将t2插队到第一个获得时间碎片，进行执行

        t3.start();     //这样就可以让三个线程按顺序执行
    }
}

class ABC extends Thread{
    public ABC(){
    }
    public ABC(String name){
        super(name);    //线程的名称
    }

    @Override
    public void run(){
        System.out.println("我是："&#