Java多线程（持续更新）

原创 已于 2025-08-01 11:02:03 修改 · 2k 阅读 · 52 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #jvm

于 2025-04-25 17:10:12 首次发布

今天的内容特别重要！！！

1.进程

2.线程【重点】

1.什么是进程

进程是独立的运行程序

比如咱们电脑软件，你启动起来以后，他就是一个进程。

qq idea，vscode等等

进程需要windows系统的分配。可以获取当前的系统的网卡，内存，显卡等

  • 独立性

各个进程之间是相互的独立的互不影响 的。录屏软件和idea没有关系的

  • 互斥性

每个软件系统都会分配一个独立端口号，如果启动一个软件以后他的端口号97。

如果再启动另外一个软件，另外一个软件如果端口也是97，这个程序就启动不了，端口被占用了

脑海里面知道开启的软件就是一个进程 即可！！！

2.什么是线程

进程是由多个或者一个线程组成的。每个进程至少得有一个线程的支撑。

脑海里面这样来想，一个进程（qq）,qq里面很多个线程在执行。线程的执行

支撑起来了进程的执行。

把一个人比作一个进程，那么你身体里面的细胞就是线程。如果没有细胞。这个人还存在吗？不存在的！！！

进程包含了线程，线程是组成进程的最小基本单位

特性:

  • 抢占式运行的【重要】

CPU在执行的时候，按照时间片来执行的，单位的时间片是抢占是执行

比如 idea qq 抢占CPU的，比如qq的线程抢到cpu，idea线程等待

我是一个cpu。你们问我问题。75个线程。同时来问我问题吗？不是

抢着问。一个问。然后其他人等待。这个人甚至还没有问完，其他的某一个人

抢到我了，他问我。大概就是效果

  • 资源共享性

一个线程可以共享当前CPU， 网卡等

Java程序:

一个Java程序就是一个进程 Demo1 就是一个应用程序 就是一个进程

一个Java程序Demo1里面至少几个线程？

两个：

main主函数线程

JVM垃圾回收器线程

3.线程和进程的区别【面试题】

进程是一个应用程序，是独立的
线程是进程中最小的基本单位。
把进程比作生产车间，每个流水线就是一个线程
进程有独立性和互斥性
线程有抢占式资源共享特性
​

4.并发和并行

并发:同时发生，轮流交替执行(执行很快所以有了 "并行的错觉" )

并行:真正意义的同时执行

比如：

你去饭店点了两个菜，生活中拿个筷子轮流夹菜哦这就是并发场景

端起盘子，同时倒到嘴里面，这就是并行场景

5.创建线程的两种方式【重点】

方式一、继承Thread类

创建线程的两种方式

  1. 一个是将一个类声明为Thread的子类，即继承Thread类。 这个子类应该重写run方法 ，然后可以创建该线程类的实例，并启动该实例的线程。

方式一、案例：
// 一个是将一个类声明为Thread的子类。
// 这个子类应该重写run类的方法Thread 。
// 然后可以分配并启动子类的实例。
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("我是myThread1线程:" + i);
        }
    }
}
class MyThread2 extends Thread {
    @Override
    public void run() {//run方法中写功能代码  就是一个线程中执行的一个功能
        for (int i = 0; i < 500; i++) {
            System.out.println("我是mythread2线程:" + i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //官方手册中说，要去实例化Thread的子类，并启动线程
        MyThread1 myThread1 = new MyThread1();
        //启动线程 使用start方法  在主线程中开启子线程
        myThread1.start();
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();
        //现在有几个线程?  4个
        //一个是MyThread1线程 一个是MyThread2线程 一个是主线程（main）  一个垃圾回收机制线程
        for (int i = 0; i < 500; i++) {
            System.out.println("主函数线程:" + i);
        }
        //发现先执行了主线程，然后再执行子线程，然后又执行主线程
        //这就线程的抢占式的运行
        /四个线程：
        //你自己吃四盘菜，咋吃？
        //一盘菜代表一个线程，一盘菜夹一下，随机的吧。
        //开启一个线程，就是在执行一个任务。
        //上面这个代码，你们执行结果和我执行的结果一样吗？绝对不一样的
        //抢占式的，随机执行线程的！！！
​
    }
}
方式一、练习 

练习:
           main主线程 打印100遍的吃大盘鸡
           子线程1 打印100遍的吃水煮肉片
           子线程2 打印100遍的吃毛血旺
           一定要注意打印的结果，多执行几遍，看看每次执行的结果是否一样！！！

方式二、实现Runable接口 

另一种方法来创建一个类后实现Runnable接口 (并不能叫做线程类，应该称为任务类) , 任务类实现了run方法。 然后任务类的实例需要被"包装"为线程，即在创建Thread时作为参数传递，然后作为一个线程启动。

​方式二、案例
//另一种方法来创建一个线程是声明实现类Runnable接口。
// 那个类然后实现了run方法。 
// 然后可以分配类的实例(创建类的对象)，在创建Thread实例时作为参数传递，并启动。
class MyThread3 implements Runnable {
​
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread3:" + i);
        }
    }
}
class MyaThread4 implements Runnable {
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread4:" + i);
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyThread3 myThread3 = new MyThread3();
        //Thread(Runnable target)  参数是Runnable这个接口对象
        //分配一个新的 Thread对象。
        Thread thread = new Thread(myThread3);
        thread.start();
        MyaThread4 myaThread4 = new MyaThread4();
        Thread thread1 = new Thread(myaThread4);
        thread1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main主线程:" + i);
        }
        //有几个线程做任务的线程  3个 一个是main主线程  一个是MyThread3
        //一个MyThread4这个线程
        //可以发现运行的结果是随机执行的！！！
​
    }
}
方式二、练习

练习:
           main主线程 打印100遍的吃大盘鸡
           子线程1 打印100遍的吃水煮肉片
           子线程2 打印100遍的吃毛血旺
           一定要注意打印的结果，多执行几遍，看看每次执行的结果是否一样！！！ 

题目：start方法和run方法的区别

在 Java 多线程中，run() 是线程执行的任务入口，像普通方法一样执行；而 start() 方法会通知 JVM 创建一个新的线程，并自动调用线程的 run() 方法。调用 start() 才真正开启一个新的线程，而直接调用 run() 方法并不会创建新线程，只是当前线程顺序执行一段代码。

6.线程下面的几个方法

1.构造方法
方法名说明
Thread()

创建一个新的线程对象，但还没有指定它要执行的任务。适合子类继承Thread后使用。此构造方法是第一种线程创建方式的核心。

Thread(Runnable target)

创建一个线程对象，并传入一个实现了Runnable接口的任务对象，线程启动后会执行这个任务。此构造方法是第二种线程创建方式的核心。

Thread(Runnable target, String name)

和上面一样，但同时给线程取一个名字，便于调试和日志分析。

2.线程方法：

static Thread

currentThread()返回对当前正在执行的线程对象的引用

String

getName() 返回此线程的名称。

void

setName(String name) 将此线程的名称更改为等于参数 name 。

int

getPriority() 返回此线程的优先级。

void

setPriority(int newPriority) 更改此线程的优先级。

设置优先并不一定优先，只是增加了执行的概率。最小值是1，最大值是10，默认的是5

static void

sleep(long millis)使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。

class MyThread1 implements Runnable {
    @Override
    public void run() {
        Thread thread = Thread.currentThread();
        //此时这个thread对象是MyThread1这个线程
        //对子线程设置名字
        thread.setName("mythread1子线程");
        System.out.println(thread.getName());//Thread-0
    }
}
class MyThread2 implements Runnable {
    @Override
    public void run() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());//狗蛋
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //currentThread() 获取当前线程对象
        Thread thread = Thread.currentThread();
        //现在thread  这个对象是哪个线程？主线程
        //为啥是main主线程
        //给main主线程设置名字
        thread.setName("主线程");
        //获取的是main主线程的名字，Jvm会给主线程还有其他线程一个默认的名字
​
        System.out.println(thread.getName());//main
//        MyThread1 myThread1 = new MyThread1();
//        Thread thread1 = new Thread( myThread1);
//        thread1.start();
​
        new Thread(new MyThread1()).start();
        //Java中默认的主线程叫main  子线程叫Thread-0  Thread-1....
        //默认的有名字，咱们能不能对线程自定义名字？能
​
        //我在启动MyThread2的这个线程的时候顺便起名字
        MyThread2 myThread2 = new MyThread2();
        //myThread2线程的名字就叫狗蛋，是在创建线程的时候就已经起好名字了
        Thread thread1 = new Thread(myThread2, "狗蛋");
        thread1.start();
​
​
    }
}
​
​

class MyThread3 implements Runnable {
    @Override
    public void run() {
        //想看一下MyThread3这个线程的优先级是几
        Thread thread = Thread.currentThread();
        thread.setPriority(10);
        System.out.println(thread.getPriority());
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread3线程:" + i);
        }
    }
}
class MyThread4 implements Runnable {
    @Override
    public void run() {
        //想看一下MyThread3这个线程的优先级是几
        Thread thread = Thread.currentThread();
        thread.setPriority(1);
        System.out.println(thread.getPriority());
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread4线程:" + i);
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
​
        //默认的优先级都是5，能不能手动去修改某一个线程的优先级？
        //可以
        Thread thread = Thread.currentThread();
        //主线程的优先级设置1
        //thread.setPriority(1);
        //获取主线程的优先级
        System.out.println(thread.getPriority());//5
        //优先级  1 ~10  1的优先级最低  10的优先级最高
        //jvm默认线程的优先级是5
//        for (int i = 0; i < 100; i++) {
//            System.out.println("主线程:" + i);
//        }
        new Thread(new MyThread3()).start();
        new Thread(new MyThread4()).start();
        //所以优先级不要用啦！！！并不一定真正的优先！！！
        //线程执行的结果不可控！！！很尴尬！！！
    }
}
​
​


class MyThread5 implements Runnable {
    @Override
    public void run() {
        try {
            //发现 Thread.sleep 有一个运行时异常，
            //但是发现没有抛出，只有try-catch 为啥?
            //sleep方法写在了run方法中了，因为
            //run方法是重写的， 父类的 public abstract void run();
            //父类有抛出吗？没有抛出，重写是比较严格的
            //父类没有抛出，子类也同样不能抛出
            Thread.sleep(10000);//10秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 500; i++) {
            System.out.println("MyThread5：" + i);
        }
    }
}
class MyThread6 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("MyThread6：" + i);
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        new Thread(new MyThread5()).start();
        new Thread(new MyThread6()).start();
        //发现运行的结果是不可控的，是随机的抢占式的
        //咱们接下来学习一个东西叫sleep  让某一个线程睡一会儿
        //这个线程在睡觉的期间不会去抢占cpu  不执行
        //现在我让MyTread5睡了一会儿。就意味着绝对MyThread6线程先执行
        //实现可控的效果
        //思考：sleep方法再开发的时候敢用不敢用？
        //不敢用。睡多久你知道吗？睡多久合适？不能确定
        //cpu最大利用化。不可能让cpu闲置
        //如果sleep睡眠时间少的话，还是抢占
        //如果sleep睡眠你时间太长的话，就会cpu就会闲置
        //没有办法把控的！！！ 接下来要学习锁！！！
    }
}
上午的内容

1.新建线程的两种方式
    1.继承Thread
    2.实现Runnable接口【开发要用的】
    代码要自己学会写的！！！
2.线程的方法
    Thread.currentThread();获取当前线程对象
    setPriority();设置优先级的
    getPriority(); 获取当前线程的优先级
    getName()；得到线程的名字
    setName();设置线程的名字
    sleep();线程的休眠

7.线程的同步和锁【重要】

为什么要进行线程的同步？

Java是允许多线程（多个线程），当多个线程操作同一个资源（咋操作）的时候，会导致得到或者打印的数据不准确。从而发生冲突。咋解决？加同步锁。

美团
淘票票
这个两个线程，都去麦同一场次的票
结果美团卖出去一张1排1列的票
结果淘票票也卖出去了1排1列的票  你感觉合适吗？
就是上面的这种结果！！！不合适的，分享同一个资源的时候，要保证分享资源的数据，合法性！！！
​
  

分析结果: 



//最理想的状态！！！
//先线程1进入到ticket=50,循环 循环结束以后 此时
//tiket=49了
//循环第二次的时候 线程2抢到资源了 此时ticket=49
//循环 打印49 tiket-- ticket=48了
//循环第三次的时候 线程2 抢到资源了， 此时ticket=48
//打印卖第48张票。ticket--  tiket=47
//线程1又抢到循环
//现在的情况是：有可能两个线程同时进入到while循环
//
class MySync implements Runnable {
    int ticket = 50;
    @Override
    public void run() {
        //
        while (true) {//死循环
            //两个线程都进入到了循环了
            //此时两个线程所持有的ticket 都是50
            //但是两个线程都要往下执行
            //有可能线程1 先执行了sout(50)  线程2在等待哦！！！
            //线程1执行了--操作并出了循环 线程1ticket = 49
            //线程1又抢到循环了 sout(49) tiket--
            //再进入倒这个循环，有可能线程2抢到这个执行权
            //线程2要往下执行输出语句  ticket=50 打印50
            if (ticket > 0) {
                //线程具有抢占式的运行
                //咱们有没有可能，线程3进入到if语句
                //此时线程1也进入到if语句了
                //线程3去打印 卖出了50张票
                //在线程1里面  ticket=50
                //线程3又抢到ticket-- 又进入到循环了  ticket = 49
                //线程3又抢到了ticket-- 又进入倒循环 ticket=48
                //线程1又抢到资源要执行，执行输出语句  tiekct=50
                System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                ticket--;
            } else {
                System.out.println("买完了");
                break;//终止循环！！！
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MySync mySync = new MySync();
        //这三个线程
        Thread thread1 = new Thread(mySync, "线程1");
        thread1.start();
        Thread thread2 = new Thread(mySync, "线程2");
        thread2.start();
        Thread thread3 = new Thread(mySync, "线程3");
        thread3.start();


    }
}

解决方案：

1.同步方法:

使用一个关键字synchronized修饰方法。因为Java对象都有一个内置的锁对象。当使用这个关键字的时候，修饰方法的时候，这个方法就会被锁保护起来被锁锁住

当一个线程进来以后，会立马锁住当前的方法。意味着只有一个线程进来，其他线程都在外面等着。

public synchronized  void run () {

}

//最理想的状态！！！
//先线程1进入到ticket=50,循环 循环结束以后 此时
//tiket=49了
//循环第二次的时候 线程2抢到资源了 此时ticket=49
//循环 打印49 tiket-- ticket=48了
//循环第三次的时候 线程2 抢到资源了， 此时ticket=48
//打印卖第48张票。ticket--  tiket=47
//线程1又抢到循环
//现在的情况是：有可能两个线程同时进入到while循环
//
class MySync1 implements Runnable {
    int ticket = 50;
    //对这个run方法加了锁 就意味着只有一个线程进入到run方法中
    //其他线程都在run方法外面等待
    @Override
    public synchronized void run() {
        //
        while (true) {//死循环
            //两个线程都进入到了循环了
            //此时两个线程所持有的ticket 都是50
            //但是两个线程都要往下执行
            //有可能线程1 先执行了sout(50)  线程2在等待哦！！！
            //线程1执行了--操作并出了循环 线程1ticket = 49
            //线程1又抢到循环了 sout(49) tiket--
            //再进入倒这个循环，有可能线程2抢到这个执行权
            //线程2要往下执行输出语句  ticket=50 打印50
            if (ticket > 0) {
                //线程具有抢占式的运行
                //咱们有没有可能，线程3进入到if语句
                //此时线程1也进入到if语句了
                //线程3去打印 卖出了50张票
                //在线程1里面  ticket=50
                //线程3又抢到ticket-- 又进入到循环了  ticket = 49
                //线程3又抢到了ticket-- 又进入倒循环 ticket=48
                //线程1又抢到资源要执行，执行输出语句  tiekct=50
                System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                ticket--;
            } else {
                System.out.println("买完了");
                break;//终止循环！！！
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MySync1 mySync = new MySync1();
        //这三个线程
        Thread thread1 = new Thread(mySync, "线程1");
        thread1.start();
        Thread thread2 = new Thread(mySync, "线程2");
        thread2.start();
        Thread thread3 = new Thread(mySync, "线程3");
        thread3.start();

        //为啥都是线程1卖出去的票？
        //很巧  线程1抢到执行权了，进入到run方法中
        //线程2和线程3在外面等着。
        //一个循环进来以后，把循环全部执行完！！！
        //会出现一家独大的情况！！！也是不符合咱们生活场景的！！！
        //咋解决？咱们 不能方法中加锁，在其他地方加锁


    }
}

换另外一种解决方法:

同步代码块:就是拥有了synchronized 关键字修饰一个语句块。被修饰的语句块会被加锁。从而实现同步。

语法格式:

synchronized  (this) {
	被加锁的代码块
}

//最理想的状态！！！
//先线程1进入到ticket=50,循环 循环结束以后 此时
//tiket=49了
//循环第二次的时候 线程2抢到资源了 此时ticket=49
//循环 打印49 tiket-- ticket=48了
//循环第三次的时候 线程2 抢到资源了， 此时ticket=48
//打印卖第48张票。ticket--  tiket=47
//线程1又抢到循环
//现在的情况是：有可能两个线程同时进入到while循环
//
class MySync2 implements Runnable {
    int ticket = 500;
    //对这个run方法加了锁 就意味着只有一个线程进入到run方法中
    //其他线程都在run方法外面等待
    @Override
    public  void run() {
        //能不能对循环加锁？不能 因为循环加锁以后，还是一个线程循环完，没有任何意义

        while (true) {//死循环
            //if语句加了锁以后
            //就意味着只有一个线程进入到if语句
            //假如线程1进入if语句了，线程2和线程3就会等待
            //线程1打印50 并--  ticket变量为49
            //线程2抢到了49 sout(49) tiket--  48
            //其他线程再抢！！！

            //核心业务 加了锁，只让一个线程进入，操作完以后。锁释放掉
            //然后这三个线程再抢。还只能进一个，再操作核心业务
            synchronized (this) {//只能让一个线程进入操作，其他线程在外面等待排队
                if (ticket > 0) {
                    //线程具有抢占式的运行
                    //咱们有没有可能，线程3进入到if语句
                    //此时线程1也进入到if语句了
                    //线程3去打印 卖出了50张票
                    //在线程1里面  ticket=50
                    //线程3又抢到ticket-- 又进入到循环了  ticket = 49
                    //线程3又抢到了ticket-- 又进入倒循环 ticket=48
                    //线程1又抢到资源要执行，执行输出语句  tiekct=50
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                    ticket--;
                } else {
                    System.out.println("买完了");
                    break;//终止循环！！！
                }
            }
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        MySync2 mySync = new MySync2();
        //这三个线程
        Thread thread1 = new Thread(mySync, "线程1");
        thread1.start();
        Thread thread2 = new Thread(mySync, "线程2");
        thread2.start();
        Thread thread3 = new Thread(mySync, "线程3");
        thread3.start();

        //为啥都是线程1卖出去的票？
        //很巧  线程1抢到执行权了，进入到run方法中
        //线程2和线程3在外面等着。
        //一个循环进来以后，把循环全部执行完！！！
        //会出现一家独大的情况！！！也是不符合咱们生活场景的！！！
        //咋解决？咱们 不能方法中加锁，在其他地方加锁


    }
}

针对于同步代码块举个例子：

上厕所的时候，有坑位，这个坑位就是资源。

三个人去抢这个资源，如果不加锁的话，会出现问题的?是的。加上锁以后就会保证数据准确性。

案例：

加锁的目的为了保证数据的准确性。
卖电影票：
    三个线程:
        淘票票
        美团
        猫眼
        100张票

​

class SaleTicket implements Runnable {
    //声明一个变量票
    //静态的变量和对象没有关系了
    private static int ticket = 100;
    @Override
    public void run() {
        //美团
​
​
​
        while (true) {
            //美团  猫眼  淘票票
            synchronized (this) {
                if (ticket > 0) {
                    //淘票票  和猫眼同时进入到if语句，但是都没有执行ticket--这个操作
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                    //所以会打印 淘票票 100   猫眼100
​
                    ticket--;
                } else {
                    System.out.println("卖完了");
                    break;
                }
            }
        }
​
    }
}
public class Demo4 {
    public static void main(String[] args) {
        SaleTicket saleTicket = new SaleTicket();
        new Thread(saleTicket, "淘票票").start();
        new Thread(saleTicket, "美团").start();
        new Thread(saleTicket, "猫眼").start();
        //淘票票卖出了第100票
        //猫眼卖出了第100票
        //淘票票卖出了第99票
        //淘票票卖出了第97票
        //淘票票卖出了第96票
        //淘票票卖出了第100票
        //淘票票卖出了第99票
        //猫眼卖出了第98票
        //猫眼卖出了第97票
​
    }
}
​

线程就是这样，不可控制，但是可以加锁。让他可控制。

作业：

1.锁的问题，一定要自己去百度一些资料
    增长自己的见识
    lock();
    unlock();
2.将今天讲东西弄懂。理解透侧！！！

今天的内容

> 1.守护线程 > > 2.死锁 > > 3.线程的生命周期 > > 4.关于Object类下面的方法和线程有关 > > 5.生产者消费者模式【难点】

1.守护线程

> 守护线程是用来守护非守护线程的。 > > 非守护线程：就是平常写的线程 > > 非守护线程一旦结束，守护线程就会自动消亡 > > 守护线程依附非守护线程，如果非守护线程消亡，那么守护线程随之消亡。

前台线程（非守护线程）与后台线程（守护线程）

后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。

前台线程：是指接受后台线程服务的线程，也称为非守护线程。，由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。

区别：

前台线程会各自运行各自的，都运行结束，java程序进程才会结束，前台线程互不干扰

后台线程需要有前台线程支持，如果前台线程都行完了，程序进程也就结束了，后台线程不管有没有运行结束，都会被终止结束

​
class MyThread1 implements Runnable {
    @Override
    public void run() {
        System.out.println(&quot;软件更新中......&quot;);
        for (int i = 1; i &lt;= 1000; i++) {
            System.out.println(&quot;downloading:&quot; + i + &quot;%&quot;);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread1());
        //在线程的启动之前调用设置守护线程的
        thread.setDaemon(true);
        thread.start();
        for (int i = 1; i &lt;= 300; i++) {
            System.out.println(&quot;主线程正在执行.....&quot;);
        }
​
    }
}

2.死锁

> 开发中禁止使用死锁。 > > 面试会问： > > 应用场景：并发场景，多线程。线程之间互不相让。得借助锁。 > > 加锁的目的是为了线程安全，但是物极必反。尤其是加了锁以后。 > > 死锁是一种状态，当两个线程互相持有对方的资源的时候，却又不主动释放这个资源的时候。会导致死锁。这两个线程就会僵持住。代码就无法继续执行。 > > 线程1 有锁1 > > 线程2 锁2 > > 线程1会等待锁2 的释放 > > 线程2会等待锁1的释放

class DeadLock implements Runnable{
    private boolean flag;//标记属性
    private Object obj1;//
    private Object obj2;
    //有参构造
​
​
    public DeadLock(boolean flag, Object obj1, Object obj2) {
        this.flag = flag;
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
​
​
    @Override
    public void run() {
        if (flag) {//如果是个true的时候，让线程1进来
            synchronized (obj1) {//锁的是obj1这个对象
                System.out.println(Thread.currentThread().getName() + &quot;拿到了锁1&quot;);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(&quot;等待锁2的释放....&quot;);
                //对obj2对象加锁的时候，结果人家线程2没有释放对obj2加的锁
                synchronized (obj2) {
                    System.out.println(Thread.currentThread().getName() + &quot;-&gt;拿到锁2&quot;);
                }
            }
        }
        if (!flag) {//如果flag是个false的话，让线程2进来
​
            synchronized (obj2) {//锁的是obj2这个对象
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + &quot;拿到了锁2&quot;);
​
                System.out.println(&quot;等待锁1的释放....&quot;);
                synchronized (obj1) {
​
                    System.out.println(Thread.currentThread().getName() + &quot;-&gt;拿到锁1&quot;);
                }
            }
        }
​
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Object obj1 = new Object();
        Object obj2 = new Object();
        //第一个线程  flag 是true
        DeadLock deadLock = new DeadLock(true, obj1, obj2);
        new Thread(deadLock, &quot;线程1&quot;).start();
        //第二个线程 flag  是flase
        DeadLock deadLock1 = new DeadLock(false, obj1, obj2);
        new Thread(deadLock1, &quot;线程2&quot;).start();
    }
}
​

3.生命周期

> 1.线程的创建，开启线程 > > 2.可运行状态: CPU等待 CPU抢占 > > 3.运行状态: ＣＰＵ等待 CPU抢占 CPU使用 > > 4.阻塞状态: 锁 sleep > > 5.消亡状态

4.和线程相关的Object类下面的方法

> Object类下面的方法: > > > public final void wait() > throws InterruptedException > > > 导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法。 换句话说，这个方法的行为就好像简单地执行呼叫wait(0) 。 > > 总结：至少两个线程，其中一个线程中使用对象.wait() 那么这个线程就会阻塞，代码不会往下执行了。如何想让这个线程往下执行呢？再开另外一个线程，使用对象.notify()去唤醒另外那个等待线程。

​
//为啥要写这个类? wait方法  需要对象来调用的额，先有类
class Message {
    private String message;
​
    public Message(String message) {
        this.message = message;
    }
​
    public String getMessage() {
        return message;
    }
​
    public void setMessage(String message) {
        this.message = message;
    }
​
    @Override
    public String toString() {
        return &quot;Message{&quot; +
                &quot;message=&apos;&quot; + message + &apos;\&apos;&apos; +
                &apos;}&apos;;
    }
}
​
//现在开始写线程，  这个线程里面有一个 对象.wait()   线程会阻塞 等待
class WaiterThread implements  Runnable {
    private Message msg;
​
    public WaiterThread(Message msg) {
        this.msg = msg;
    }
​
    @Override
    public void run() {
​
        //获取当前线程的名字
        String name = Thread.currentThread().getName();
        synchronized (msg) {
            System.out.println(name + &quot;等待唤醒时间:&quot; + System.currentTimeMillis());
            try {
                //当对象调用wait方法的时候，锁会释放，进入到对象的等待池中。
                msg.wait();//让线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(&quot;123456&quot;);
            System.out.println(name + &quot;被唤醒的时间:&quot; + System.currentTimeMillis());
            System.out.println(name + &quot;线程&quot; + msg.getMessage());
        }
​
​
    }
}
class NotifierThread implements Runnable {
    private Message msg;
​
    public NotifierThread(Message msg) {
        this.msg = msg;
    }
​
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String name = Thread.currentThread().getName();
        System.out.println(name + &quot;开始唤醒等待线程&quot;);
//        Thread.sleep(1000);
        synchronized (msg) {
            msg.setMessage(&quot;我是修改之后的messgae属性的值&quot;);
            //msg.notify();
            msg.notifyAll();
        }
​
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Message message = new Message(&quot;我是messag属性&quot;);
        WaiterThread waiterThread = new WaiterThread(message);
        new Thread(waiterThread, &quot;wait&quot;).start();
        new Thread(waiterThread, &quot;wait1&quot;).start();
        new Thread(waiterThread, &quot;wait2&quot;).start();
        NotifierThread notifierThread = new NotifierThread(message);
        new Thread(notifierThread, &quot;notify&quot;).start();
    }
}

总结：

新建两个线程：

  •         一个是等待线程 :

        线程里面的代码从上往下执行的，但是使用object.wait(),就这个方法一用，你的线程就
        阻塞了，就处于等待状态。意味着当前的代码到了wait方法以后的代码暂时不执行了

  •         另外一个是唤醒线程 :

        唤醒线程中使用object.notify()方法，这个方法是专门唤醒刚才那个等待线程。让等待线程继续执行

5.生产者消费者模式【重点难点】

> 生活中例子： > > 卖家： 汽车厂商 > > 买家: 咱们75名学生 > > 张启想买一辆 比亚迪汉 ， 告知汽车厂商我要买车。这个张启会进入倒等待状态 > > 等到比亚迪厂家造完完以后，再通知张启来提车。如果比亚迪厂家有现车，张启就直接提车。 > > 如果产品需要生产的话，消费者进入到阻塞状态 > > 如果产品不需要生产的话，消费者直接购买


​
//为啥要写这个类？这个类是作为两个线程之间通信的桥梁
class Goods {
    private String name;//名字
    private double price;//价格
    private boolean isProduct;//是否有这个商品， true 需要生产
    //false   不需要生产商品
​
​
    public Goods(String name, double price, boolean isProduct) {
        this.name = name;
        this.price = price;
        this.isProduct = isProduct;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public double getPrice() {
        return price;
    }
​
    public void setPrice(double price) {
        this.price = price;
    }
​
    public boolean isProduct() {
        return isProduct;
    }
​
    public void setProduct(boolean product) {
        isProduct = product;
    }
​
    @Override
    public String toString() {
        return &quot;Goods{&quot; +
                &quot;name=&apos;&quot; + name + &apos;\&apos;&apos; +
                &quot;, price=&quot; + price +
                &quot;, isProduct=&quot; + isProduct +
                &apos;}&apos;;
    }
}
//消费者线程
class Customer implements Runnable {
    private Goods goods;
​
    public Customer(Goods goods) {
        this.goods = goods;
    }
​
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (true) {
            synchronized (goods) {
                //一直消费
                //goods.isProduct()  true  需要生产 没有商品
                //false  不需要生产的
                if (!goods.isProduct()) {
                    System.out.println(&quot;消费者购买了:&quot; + goods.getName() + &quot;,价格为:&quot; + goods.getPrice());
                    //购买完以后 商品没了  isProduct 是true  没有商品了
                    goods.setProduct(true);
                    //唤醒生产者去生产
                    goods.notify();
                } else {
                    //需要生产  消费者进入阻塞
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
​
                }
            }
        }
​
    }
}
//生产者线程
class Productor implements Runnable {
    private Goods goods;
​
    public Productor(Goods goods) {
        this.goods = goods;
    }
​
    @Override
    public void run() {
        int count = 0 ;
        while (true) {//一直生产商品
            synchronized (goods) {
                if (goods.isProduct()) {//true  需要生产者
                    //造车，奇数造一种车， 偶数的话造另外一种车
                    if (count % 2 == 0) {//偶数
                        goods.setName(&quot;玛莎拉蒂&quot;);
                        goods.setPrice(200);
                    } else {
                        goods.setName(&quot;五菱宏光&quot;);
                        goods.setPrice(400);
                    }
                    //生产完以后一定要记得 将标记改false
                    goods.setProduct(false);
                    System.out.println(&quot;生产者生产了:&quot; + goods.getName() + &quot;，价格为:&quot; + goods.getPrice());
                    count++;
                    //生产者完了以后，人家消费者在等待这你呢
                    //唤醒消费者
                    goods.notify();
                } else {
                    //不需要生产车，你就等着就行
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
​
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Goods goods = new Goods(&quot;东风&quot;, 89, false);
        //false不需要生产的  谁阻塞 生产者阻塞
        //最好是让生产者线程先执行
        Productor productor = new Productor(goods);
        new Thread(productor).start();
        Customer customer = new Customer(goods);
        new Thread(customer).start();
        /**
         * 消费者购买了:东风,价格为:89.0
         * 生产者生产了:玛莎拉蒂，价格为:200.0
         * 消费者购买了:玛莎拉蒂,价格为:200.0
         * 生产者生产了:五菱宏光，价格为:400.0
         * 消费者购买了:五菱宏光,价格为:400.0
         * 生产者生产了:玛莎拉蒂，价格为:200.0
         * isProduct = false
         * 走了else  代码是生产者阻塞了 消费在睡了一秒之后立马执行
         * 看消费者   有商品 买走了，之后   isProduct=true
         * 唤醒生产者了，
         * 生产者生产了:玛莎拉蒂，价格为:200.0  isProduct=false
         *
         */
​
    }
​
}
陈姥姥
关注
Java零基础之多线程篇：多线程最佳实践
喵手的博客
08-01 2160
在计算机科学领域，多线程是一种重要的编程概念。它允许程序同时执行多个任务，提高了程序的并发性和响应性。对于Java开发者而言，了解和掌握多线程编程是非常重要的一项技能。本文将从零基础开始介绍Java多线程的概念和用法，帮助读者理解多线程的原理和实践技巧。我们将深入探讨多线程的最佳实践，包括源代码解析、应用场景案例、优缺点分析和具体的Java代码测试用例。本文将带领读者逐步学习Java多线程编程的基础知识和高级概念。我们将通过详细的源代码解析和实际应用场景案例，帮助读者理解多线程的内部工作原理和使用技巧。
java-多线程持续
随笔
05-21 543
Thread.yield()：提出释放CPU时间⽚的请求。不会释放锁，线程依然处于RUNNABLE状态，即调度权让给别⼈，但⽴刻可以回到竞争线程锁的状态。 Thread.sleep():调⽤后线程处于阻塞状态,注：线程状态处于BLOCKED或WAITING或TIME_WAITING这三种统称为堵塞状态。 线程安全的常用数据结构 HashMap：ConcurrentHashMap ArrayList：CopyOnWriteArrayList Set：CopyOnWriteArraySet 关键字 vol
Java 多线程详解
goTsHgo的博客
08-30 1750
多线程（Multithreading）是指在一个程序中同时执行多个线程的能力。线程是进程中的一个执行路径，多线程允许程序在同一时间内执行多个操作。Java 中的多线程可以通过并发处理来提高程序的性能和响应速度，尤其在处理复杂计算、大量 I/O 操作或并发任务时非常有用。多线程使得程序可以同时执行多个任务，充分利用CPU资源，提升程序性能，增强响应性，并简化程序的复杂度。尽管多线程编程带来了一些挑战，如线程安全和死锁问题，但合理设计和使用多线程可以显著改善程序的整体表现。
Java多线程笔记
weixin_44159128的博客
04-15 1689
Java基础中的多线程基本实现方法
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
热门推荐
qq_35716689的博客
03-25 25万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
java 多线程测试_java多线程——并发测试
weixin_26937243的博客
02-12 1706
这是多线程系列第六篇，其他请关注以下：编写并发程序时候，可以采取和串行程序相同的编程方式。唯一的难点在于，并发程序存在不确定性，这种不确定性会令程序出错的地方远比串行程序多，出现的方式也没有固定规则。这对程序的应用会造成一些困难，那么如何在测试中，尽可能的暴露出这些问题，并且了解其性能瓶颈，这也是对开发者带来新的挑战。本篇基于多线程知识，梳理一些多线程测试需要掌握的方法和原则，以期望可能的在开发阶...
JAVA多线程的变量共享
weixin_37632716的博客
05-25 1899
//非同步共享变量 public class Novisibility{ private static boolean ready; private static int number; //创建线程，当ready值为true的时候，输出number值 private static class ReaderThread extends Thread{ public void run(){ while(!ready){ Thread.yield();
Java多线程下——各类锁的详解
weixin_45696320的博客
08-26 3412
假设男主是一个锁, 女主是一个线程. 如果只有这一个线程来使用这个锁, 那么男主女主即使不领证结婚(避免了高成本操作), 也可以一直幸福的生活下去.但是,但是，但是，女配出现了, 也尝试竞争男主, 此时不管领证结婚这个操作成本多高, 女主也势必要把这个动作完成了, 让女配死心.比如一个递归函数里有加锁操作，递归过程中这个锁会阻塞自己吗？实际开发过程中, 使用细粒度锁, 是期望释放锁的时候其他线程能使用锁,但是实际上可能并没有其他线程来抢占这个锁. 这种情况 JVM 就会自动把锁粗化, 避免频繁申请释放锁..
java for循环内执行多线程
qq_38650613的博客
03-23 2万+
一、java用多线程来加快循环效率 Executors（线程池）、CountDownLatch（闭锁）
java多线程并发
weixin_48288539的博客
10-27 3554
介绍java线程并发机制
java 多线程消费kafka,多线程 Kafka 消费者
weixin_31558841的博客
03-14 1126
1. 为什么需要多线程假设我们实现了一个通知模块允许一些用户通过这个模块订阅一些来自其他用户..其他应用的通知. 我们的模块所读取的就是其他用户或应用写入到 Kafka 集群的消息. 这个例子里面, 我们将创建一个消费者订阅 Kafka 的主题来实现.期初, 所有的事情看起来都还不错. 然而, 当其他用户和应用产生通知的数量逐渐增多, 消息增加的速度已经超过了我们的模块处理的速度时, 会发生什么呢...
精选资源
Java多线程端口快速扫描
08-25
Java多线程端口扫描是网络管理与安全领域中常用的一种技术，主要用于检测网络设备上哪些端口处于开放状态，从而分析网络的安全性或者优化网络配置。本程序通过利用Java的多线程特性，提高了扫描速度，使得在短时间内...
java多线程作业.docx
06-29
### Java多线程知识点解析 #### 一、Java多线程概述 Java作为一种现代编程语言，内置了对多线程的支持。多线程允许应用程序同时处理多个任务，从而提高程序的响应性和整体性能。在多线程环境中，一个程序可以包含...
深入理解JAVA多线程之线程间的通信方式
09-02
在Java多线程编程中，线程间的通信是至关重要的，因为它确保了多个并发执行的任务能够协调工作，避免数据不一致性和死锁等问题。本文将深入探讨两种主要的线程间通信方式：同步机制和基于轮询的方式。 1. 同步机制...
阿里Java面试被问：单元测试的最佳实践
2501_94505843的博客
01-04 893
本文系统介绍了软件测试的最佳实践，主要包含以下内容：1. 测试金字塔原则，推荐70%单元测试+20%集成测试+10%端到端测试的比例；2. 测试代码质量标准，包括命名规范、AAA模式等；3. Mock与Stub的使用场景和区别；4. 测试数据管理策略；5. 断言最佳实践；6. 测试隔离与可重复性；7. 测试性能与维护建议；8. 边界条件测试方法；9. 有意义的测试覆盖率目标；10. TDD开发流程。文章提供了大量代码示例，并总结了单元测试检查清单和测试金字塔指导原则，强调应重点关注业务逻辑、复杂算法和边界条
面向微服务事件驱动与异步消息可靠处理的互联网系统高可用设计与多语言工程实践分享
2501_94180531的博客
01-05 444
事件驱动解耦服务，提高吞吐可靠投递与幂等消费保证消息一致性监控、重试与顺序控制是稳定性的关键微服务事件驱动与异步消息可靠处理，使系统在高并发和复杂业务场景下保持稳定与可控。通过在多语言系统中统一幂等语义、结合可靠投递、顺序控制和监控策略，互联网系统能够在异步流程中实现高可用和长期可维护性。这篇关于事件驱动与异步消息可靠处理的工程实践分享，希望为你在微服务高可用设计中提供可落地、长期有效的参考思路。
TDengine JAVA 语言连接器入门指南
TDengine(老段）专注时序数据库领域
01-04 1773
JAVA 语言连接器
windows下的守护进程|nssm
slongzhang的博客
01-06 1106
NSSM（Non-Sucking Service Manager）是Windows系统中将普通程序封装为系统服务的工具。使用步骤包括：下载解压NSSM，以管理员身份运行CMD/PowerShell；通过图形界面或命令行安装服务，配置可执行文件路径、参数等；使用start/stop/restart命令管理服务；支持通过edit命令修改配置或remove删除服务；建议配置日志功能方便排查问题。核心功能是实现进程守护，确保程序异常退出后自动重启。
SpringBoot3 + GraalVM安装和初次打包
最新发布
风不知从何处起的小屋
01-08 508
本文介绍了使用GraalVM将Spring Boot项目打包为原生可执行文件的完整流程。
Java多线程下载网络文件实现
虽然源码未提供，但实现多线程下载可能需要创建一个线程池，或者使用Java的并发工具如`ExecutorService`来管理和控制下载线程。每个线程应该有自己的开始和结束位置，以避免下载的重复或遗漏。 8. **进度反馈**： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值