05. java线程基础

最新推荐文章于 2024-06-12 23:40:32 发布
最新推荐文章于 2024-06-12 23:40:32 发布
阅读量1.6k 收藏 42
点赞数 53
分类专栏： 经典游戏坦克大战项目的学习和制作 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54915265/article/details/135902199
版权

05. java线程基础

01. 线程相关概念

1. 程序

​ 是为完成特定任务、用某种语言编写的一组指令的集合。简单来说：就是我们写的代码

2. 进程

  1. 进程是指运行中的程序，比如我们使用微信，就启动了一个进程，操作系统会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间
  2. 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生，存在和消亡的过程

3. 什么是线程

  1. 线程是由进程创建的，是进程的一个实体
  2. 一个进程可以有多个线程
  3. 后面会把多线程加入到坦克大战中

4. 其他相关概念

  1. 单线程：同一个时刻，只允许执行一个线程
  2. 多线程：同一个时刻，可以执行多个线程，比如：一个qq线程，可以同时打开多个聊天窗口，一个迅雷可以同时下载多个文件
  3. 并发：同一个时刻，多个任务交替执行，造成一种“貌似同时“的错觉，简单地说，单核CPU实现的多任务就是并发
  4. 并行：同一个时刻，多个任务同时执行。多核CPU可以实现并行。
  5. 要查看自己的核心数量可以看设备管理器，假如要在idea中查看，我们可以写一串代码
public class CpuNum {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        //1. 获取当前cpu数量/核心数量
        int cpuNums = runtime.availableProcessors();
        System.out.println("当前cpu核心个数" + cpuNums);
    }
}

02. 线程基本使用

1. 创建线程的两种方式

​ 在java中线程来使用有两种方法

  1. 继承Thread类，重写run方法
  2. 实现Runnable接口，重写run方法

2. 线程应用案例-继承Thread

  1. 请编写程序，开启一个线程，该线程每隔一秒。在控制台输出“喵喵，我是小猫咪”
  2. 当输出8次 喵喵，我是小猫咪，结束该线程
  3. 使用JConsole 监控线程执行情况，并画出线程示意图
    1. 我们可以修改下面代码中main进程中for循环次数为60，cat类中循环次数改为80
    2. 然后，我们运行程序，在终端输入jconsole，在弹出的界面中，建立连接，查看线程
    3. 不会使用也没有关系，只要记住主线程结束后，有子线程继续运行，不会导致程序的结束
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //4. 创建一个Cat对象，可以当做线程使用
        Cat cat = new Cat();
        cat.start();//4.1 启动线程
        /*  (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0() 是本地方法，是JVM调用，底层是c/c++ 实现的
            //真正实现多线程的效果，是start0(), 而不是 run
            private native void start0();
         */
        //4.2 说明：当main进程启动一个子线程 Thread-0，主线程不会堵塞，会继续执行。
        // 比如我在后面继续写了一些代码.
        //4.3 主线程和子线程是交替执行。。

        System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字 mian
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程 i=" + i);
            //让主线程休眠
            Thread.sleep(1000);
        }
    }
}
//1. 当一个类继承了 Thread类，该类就可以当做线程使用
//2. 我们会重写run方法，写上自己的业务代码
//3. Thread 类 实现了 Runnable 接口的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class Cat extends Thread {
    int times = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑
        while (true) {
            //3.1 该线程每隔一秒，在控制台输出“喵喵，我是小猫咪”
            System.out.println("喵喵，我是小猫咪" + (++times) + "线程名" + Thread.currentThread().getName());
            //3.2 让该线程休眠1秒 异常处理使用快捷键 ctrl + alt + t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 80) {
                break;
            }
        }
    }
}
  1. 为什么没在main方法中使用cat.start(); 没有直接使用run方法，因为你在main中调用run方法，只是单纯的调用了一个方法，而没有启动线程
  2. 线程示意图
    在这里插入图片描述
  3. start() 方法调用 start0()方法后, 该线程并不一定会立马执行, 只是让线程变成了可运行状态.具体什么时候执行,取决于cpu, 由cpu统一调度

3. 线程应用案例-实现Runnable接口

1.基本说明
  1. java是单继承的, 在某些情况下一个雷可能已经继承了某个父类, 这时再用继承Thread类方法来创建线程显然不可能了
  2. java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程
2. 应用案例

​ 请编写程序，该程序可以每隔1秒。在控制台输出“hi!"，当输出10次后，自动退出。使用Runnable接口的方式实现

  1. 这里我们不能直接使用start，使用了设计模式【代理模式】=> 代码模拟实现Runnable接口 开发线程机制
public class Thread02 {
    public static void main(String[] args) {
//        Dog dog = new Dog();
//        //1. dog.start(); 这里不能使用start
//        //1.1 创建了Thread对象，把dog对象（实现Runnable），放入Thread
//        Thread thread = new Thread(dog);
//        thread.start();
        
		//线程代理
        Tiger tiger = new Tiger();
        Proxy proxy = new Proxy(tiger);
        proxy.start();
    }
}
// 2. 线程代理类,模拟了一个最简单的Thread类
class Proxy implements Runnable {
    //2.1 可以把proxy类当做 ThreadProxy（Thread代理）
    private Runnable target = null; //属性 类型是Runnable
    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定Tiger
        }
    }
    public Proxy(Runnable target) {
        this.target = target;
    }
    public void start() {
        start0();//这个方法真正实现多线程方法
    }

    private void start0() {
        run();
    }
}
class Animal {}
class Tiger extends Animal implements Runnable {

    @Override
    public void run() {
        System.out.println("老虎叫");
    }
}

class Dog implements Runnable {
    int count = 0;
    public Dog() {
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("小狗汪汪叫" + (++count) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

4. 线程使用应用案例-多线程执行

​ 请编写一个程序 ，创建两个线程，一个线程每隔1秒输出“hello，world” 输出 10次，退出，一个线程每隔1秒输出 “hi”，输出5次退出（目的主要在于练习）

package com.yzjedu.threaduse;

/**
 * 03. main线程启动两个子线程
 */
public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread = new Thread(t1);
        Thread thread1 = new Thread(t2);
        thread.start();//启动第一个线程
        thread1.start();//启动第二个线程
    }
}
class T1 implements Runnable {
    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hello world" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}
class T2 implements Runnable {
    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hi" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                break;
            }
        }
    }
}

03. 继承Thread实现Runnable接口的区别

1. 主要区别

  1. 从java设计者来看，通过继承Thread或者实现Runnable接口来创建线程本质上昂没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
  2. 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

例如：

T3 = new T3("hello");
Thread thread01 = new Thread(t3);
Thread thread02 = new Thread(t3);
thread01.start();
thread03.start();
//两个线程同时执行一个对象t3，共享资源

2. 案例

[售票系统]，编程模拟三个售票窗口售票100，分别使用继承Thread和实现Runnable方式、并分析有什么问题？

/**
 * 使用多线程，模拟三个窗口同时售票100张
 */
public class SellTicket {
    public static void main(String[] args) {
        //1. 继承Thread
//        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        //这里出现了票数超卖问题
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();
        //2. 实现Runnable接口
        SellTicket02 sellTicket02 = new SellTicket02();
        // 这里还是出现了票数超卖问题
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();

    }
}
//1. 使用Thread方式
class SellTicket01 extends Thread {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName()+"售出一张票"
                    + " 剩余票数" + (--ticketNum));
        }
    }
}
// 实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;
    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName()+"售出一张票"
                    + " 剩余票数" + (--ticketNum));
        }
    }
}

​ 我们发现运行这个程序后有票数超卖的问题，这个不是代码的问题，而是线程安全的问题，我们在后面的内容中会解决这个问题

04. 线程终止

1. 基本说明

  1. 当线程完成任务后，会自动退出
  2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

2. 应用案例

需求：启动一个线程t，要求在main线程中停止线程t，用编程实现

/**
 * 线程终止问题
 */
public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();
        //1.1 如果希望main线程去控制 t1 线程的终止，必须可以修改
        //1.2 让 t1 退出run方法，从而终止 t1线程 -> 通知方式
        //1.3 方法就是在主线程中 修改loop为false

        //1.4 让主线程休眠10 秒，再通知线程退出
        System.out.println("主线程休眠10秒");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}
class T extends Thread {
    private int count = 0;
    //1. 设置一个变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {
            System.out.println("Tthread 运行中" + (++count));
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

05. 线程常用方法

1. 常用方法第一组

  1. setName：设置线程名称，使之与参数name相同
  2. getName：返回该线程的名称
  3. start：该线程开始执行；java虚拟机底层调用该线程的 start0方法
  4. run：调用线程对象run方法；
  5. setPriority：更改线程的优先级
  6. getPriority：获取线程的优先级
  7. sleep：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
  8. interrupt：中断线程
1. 注意事项和细节
  1. start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程
  2. 线程优先级的范围
  3. interrupt，中断线程，但没有真正的结束线程。所以一般用于中断正在休眠线程
  4. sleep：线程的静态方法，使当前线程休眠
2. 应用案例
/**
 * 常用方法
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试
        T t = new T();
        t.setName("小白");
        t.setPriority(Thread.MIN_PRIORITY);//1
        t.start();//启动线程

        //我们让主线层打印5次够了，然后我们中断子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("继续吃" + (i + 1));
        }
        System.out.println(t.getName() + "优先级是" + t.getPriority());
        t.interrupt();//当执行到这里，就会中断 t线程的休眠
    }
}

class T extends Thread { //自定义线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "吃饺子···" + i);
            }
            try {
                Thread.sleep(20000);//5秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时，就会 catch一个异常，可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常
                System.out.println(Thread.currentThread().getName() + "被interrupt了");
            }
        }
    }
}

2. 常用方法第二组

  1. yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以不一定礼让成功
  2. join：线程的插队。插队的线程一旦插队成果，则可定先执行完插入的线程所有的任务
1. 测试案例

案例：创建一个子线程，每隔1s吃一个包子， 吃20个，主线程每隔1秒吃一个包子，吃20个。当主线程吃了5个包子的时候，让子线程吃。

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

        for (int i = 1; i <= 20 ; i++) {
            Thread.sleep(1000);
            System.out.println("主线程吃了 " + i + " 包子");
            if (i == 5) {
                System.out.println("主线程让子线程先吃");
                t2.join();//这里相当于让t2 线程先执行完毕
//                t2.yield();//这里礼让不一定成功
                System.out.println("主线程让子线程接着吃");
            }
        }
    }
}
class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠一秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程吃了 " + i + " 包子");
        }
    }
}
2. 综合练习

要求：

  1. 主线程每隔1s,输出hi,一共10次
  2. 当输出到hi 5时，启动一个子线程(要求实现Runnable),每隔1s输出hello ,等该线程输出10次hello后，退出
  3. 主线程继续输出hi，直到主线程退出
public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        T3 t3 = new T3();
        Thread threadT3 = new Thread(t3);
        for (int i = 1; i <= 10 ; i++) {
            System.out.println("hi" + i);
            Thread.sleep(1000);
            if (i == 5) {
                threadT3.start();//启动了线程，输出hello
                threadT3.join();//立即将t3子线程，先执行
            }
        }
    }
}
class T3 implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 10 ; i++) {
            System.out.println("hello" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3. 用户线程和守护线程

  1. 用户线程：也叫工作线程，当线程的任务执行完或通知方式 结束
  2. 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
    1. 在我们前面的学习内容中，我们知道当主线程结束的时候，子线程里如果有无限循环等等，那么子线程不会自动结束
    2. 守护线程的作用就是：在主线程结束后，无论子线程是否继续执行完毕都会自动结束
  3. 常见的守护线程：垃圾回收机制
1. 应用案例

​ 我们测试如何将一个线程设置成守护线程

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //1. 如果我们希望当main线程结束后，子线程自动结束
        // 只需要将子线程设为守护线程
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();

        for (int i = 1; i <= 10; i++) {
            System.out.println("主线程辛苦的工作");
            Thread.sleep(1000);

        }
    }
}
class MyDaemonThread extends Thread {
    @Override
    public void run() {
        for (; ; ) {//无限循环
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程在辛苦的工作...");
        }
    }
}

06. 线程的生命周期

1. JDK中用Thread.State 枚举表示了线程的几种状态

在这里插入图片描述

2. 线程状态转换图

在这里插入图片描述

3. 写程序查看线程状态

public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + "状态 " + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + "状态 " + t.getState());
            Thread.sleep(500);
        }
        System.out.println(t.getName() + "状态 " + t.getState());
    }
}
class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

07. 线程同步

1. Synchronized

1. 线程同步机制
  1. 在多线程编程，-些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
  2. 也可以这样理解:线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作.
2. 同步具体方法-Synchronized
  1. 同步代码块
    synchronized (对象) {//得到对象的锁，才能操作同步代码
    //需要同步代码;
    }
  2. synchronized还可以放在方法声明中，表示整个方法-为同步方法
    public synchronized void m (String name) {
    //需要同步代码
    }
  3. 假设有一个办公室里只有一个咖啡机，有多个同事想在同一时刻取咖啡。为了防止在取咖啡的过程中发生混乱，我们需要引入线程同步。
    1. 无线程同步（可能会发生问题）： 就好像办公室里的每个同事都可以随时走到咖啡机前取咖啡，而没有任何限制。这样可能导致多个人同时操作咖啡机，可能发生倒咖啡、撞到一起的情况。
    2. 使用线程同步： 现在我们在咖啡机前设置一扇门，每个同事在取咖啡前都需要先把门关上（上锁），完成取咖啡后再把门打开（解锁）。这样，一次只能有一个同事进入咖啡机区域，避免了混乱。
  4. 使用synchronized解决前面的售票系统的超卖问题
public class SellTicket {
    public static void main(String[] args) {
        //1. 继承Thread
//        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        //这里出现了票数超卖问题
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();

//        //2. 实现Runnable接口
//        SellTicket02 sellTicket02 = new SellTicket02();
//        // 这里还是出现了票数超卖问题
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
        
        //3.2 线程同步
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();


    }
}

//3. 实现接口方式，使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;
    private boolean loop = true;
    public synchronized void sell() { //3.1 同步方法，在同一个时刻只能有一个线程来操作，run方法
        if (ticketNum <= 0) {
            System.out.println("售票结束");
            loop = false;
            return;
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName()+"售出一张票"
                + " 剩余票数" + (--ticketNum));
    }
    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}

//1. 使用Thread方式
class SellTicket01 extends Thread {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName()+"售出一张票"
                    + " 剩余票数" + (--ticketNum));
        }
    }
}

// 2. 实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;
    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName()+"售出一张票"
                    + " 剩余票数" + (--ticketNum));
        }
    }
}

3. 分析同步原理

在这里插入图片描述

08. 互斥锁

1. 基本介绍

  1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  2. 每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任意时刻，只能有一个线程访问对象
  3. 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任意时刻只能由一个线程访问
  4. 同步的局限性：导致程序的执行效率降低
  5. 同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是同一个对象）
  6. 同步方法（静态的）的锁为前类本身。类.class

2. 使用互斥锁解决售票问题

代码块加锁，和方法上加锁

public class SellTicket {
    public static void main(String[] args) {
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();


    }
}

//3. 实现接口方式，使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;
    private boolean loop = true;
    
    //5. 同步方法（静态的）的锁为当前类本身
    //5.1 public synchronized static void m1() {} 锁加在SellTicket03.class
    //5.2 如果在静态方法中，实现一个同步代码块
    public synchronized static void m1() {}
    public static void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("hhhh");
        }
    }
    Object object = new Object();
    //4. 说明
    //4.1 public synchronized void sell() {} 就是一个同步方法
    //4.2 这时锁在 this对象
    //4.3 也可以在代码块上写 synchronized
    public /*synchronized*/ void sell() { //3.1 同步方法，在同一个时刻只能有一个线程来操作，run方法
        synchronized (/*this*/ object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                loop = false;
                return;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
                    + " 剩余票数" + (--ticketNum));
        }
    }
    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}

3. 注意事项和细节

  1. 同步方法如果没有使用static修饰，默认锁的对象为this
  2. 如果方法使用static修饰，默认锁的对象：当前类.class
  3. 实现步骤：
    1. 需要先分析上锁的代码
    2. 选择同步代码块或同步方法
    3. 要求多个线程的锁对象为同一个就行

09. 线程死锁

1. 基本介绍

​ 多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程中是一定要避免死锁的发生

2. 应用案例

妈妈：你先完成作业，才让你玩手机
小明：你先让我玩手机，我才完成作业

3. 模拟线程死锁

package com.yzjedu.synchronized_;

/**
 * 12. 模拟线程死锁
 */
public class DeadLock_ {
    public static void main(String[] args) {
        //模拟一个锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}

//线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();//保证多线程，共享一个对象，这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) { //构造器
        this.flag = flag;
    }

    @Override
    public void run() {

        //下面业务逻辑的分析
        //1. 如果flag 为 T， 线程A就会得到/持有o1 对象锁，然后尝试获取o2 对象锁
        //2. 如果线程A 得不到o2对象锁，就会Blocked
        //3. 如果flag 为 F，线程B就会先得到/持有o2 对象锁，然后尝试获取o1 对象锁
        //4. 如果线程B 得不到 o1 对象锁，就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) {//这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }

    }
}

10. 释放锁

1. 下面的操作会释放锁

  1. 当前线程的同步方法、同步代码块执行结束
    案例: . 上厕所，完事出来
  2. 当前线程在同步代码块、同步方法中遇到break、 return。
    案例:没有正常的完事，经理叫他修改bug,不得已出来
  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
    案例:没有正常的完事，发现忘带纸，不得已出来
  4. 当前线程在同步代码块，同步方法中执行了线程wait()方法，当前线程暂停，并释放锁
    案例:没有正常完事，觉得需要酝酿下，所以出来等会再进去

2. 下面的操作不会释放锁

  1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
    案例：上厕所，太困了，在坑位上眯了一会
  2. 线程执行同步代码块时，其他线程调用了suspend()方法将该线程挂起，该线程不会释放锁。
    提示：应该尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
绝世小帅
关注
  • 53
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java线程基础
12-21
注：多线程下载、断点续传中多线程并不是提高了宽带速度，而是提高了程序的效率（打个比方就是本来是一个干，多线程就是多个人一起做一件事，并且彼此之间独立，即每个人负责一部分,因为是独立的，所以一个出问题...
【Java学习笔记】63 -坦克大战1.3-敌方发射子弹，击中坦克消失并爆炸，敌人坦克随机移动，规定范围限制移动
qq_41891655的博客
11-06 1004
越写越能体会什么是屎山代码，还得多练面向对象的编程思想
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
Java基础之多线程.md
11-10
Java多线程，Java基础，并发
java线程的基础实例解析
08-28
主要介绍了java线程的基础实例解析，具有一定借鉴价值,需要的朋友可以参考下
java线程基础总结笔记
01-20
1.线程安全 1.1什么是线程安全？ 就是当多个线程访问某一个类（对象或方法)时，这个类（对象或方法)始终都能表现出正确的行为，那么这个类（对象或方法)就是线程安全的。 1.2 synchronized关键字 可以在任意对象及...
简单的项目部署脚本（转载）
u010230019的博客
06-09 569
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
性能狂飙：SpringBoot应用优化实战手册
Geek_H
06-06 905
想要让你的SpringBoot应用像赛车一样在性能赛道上狂飙吗？《性能狂飙：SpringBoot应用优化实战手册》将是你的最佳导航。不仅详细介绍了性能分析工具的使用，还深入探讨了代码层面的优化技巧，让你的应用在性能上无懈可击。更有数据库连接池的优化秘籍，应用层与网络的优化策略，以及持续性能监控的重要性。跟随这本手册，让你的应用性能狂飙，赢得用户的青睐和市场的尊重！
java.lang.reflect.Type是什么
最新发布
yuchangyuan5237的博客
06-12 219
通过 java.lang.reflect.Type 接口及其实现，Java 提供了一个强大的机制，用于在运行时检查和操作类型信息。这在编写通用库、框架和工具时特别有用，因为它允许你处理泛型类型和其他复杂类型结构。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 324
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
设计模式之装饰器模式
丿微风乍起的博客
06-05 1314
装饰器模式是一种结构型设计模式，它允许我们在不改变原有对象结构的情况下，动态地给对象增加一些职责（即增加其额外功能）。其核心在于通过组合而非继承的方式来扩展对象的功能。Component: 这是抽象组件接口，所有的具体组件和装饰器都必须实现这个接口。Concrete Component: 具体组件，这是我们要装饰的基本对象，它实现了Component接口。Decorator: 抽象装饰器，也是实现Component接口的，它包含一个对Component类型的引用，通常在构造函数中初始化。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 472
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
KK爱Coding的博客
06-11 228
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 754
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
Invalid keystore format，获取安全码SHA1值出错
yfy1907的博客
06-11 131
Invalid keystore format 错误
从零手写实现 nginx-20-placeholder 占位符 $
06-12 371
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat除了内置变量，Nginx 还允许用户自定义变量。自定义变量可以在set指令中定义。在这个例子中，定义了一个自定义变量，其值为，并在响应中返回这个值。Nginx 支持占位符的主要目的是提供更高的灵活性和动态性，使其能够适应各种复杂的应用场景和需求。
【使用ObjectSizeCalculator计算对象内存大小】
歪比巴卜
06-12 64
使用ObjectSizeCalculator计算对象内存大小的总结
Volatile变量
ddidi111的博客
06-06 201
在C语言中，volatile关键字可以用来提醒编译器它后面所定义的变量随时有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数据。如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。volatile关键字用于告诉编译器该变量可能会被意外地修改，因此编译器在对该变量进行优化时需要特殊处理。当一个变量被声明为volatile时，每次对该变量的读写操作都会直接访问内存，而不是使用缓存值。
【冲刺秋招，许愿offer】第 一 天
Panci_的博客
06-08 406
现在技术还是菜的一批，中等难度的算法题很难一次(一小时)解出来，项目稍微一深挖或者问点视频中没讲到的扩展性问题直接拉跨化身聋哑人，牛客面经越看越焦虑，里面问到的八股也不是都会，哎，感觉给我大厂面试机会也是秒挂，前面摆烂两个月了，秋招将至，再冲击一下，希望能拿到个好点的offer。逻辑过期：加一个字段来表示是否过期，业务逻辑变为，看判断是否过期，过期，获取锁，开启子线程进行缓存重建，其他线程以及主线哼返回旧数据。缓存击穿问题是由于热点Key过期了，导致大量请求到达数据库，可以用互斥锁或者逻辑过期。
java多线程基础知识
07-28
Java多线程基础知识主要包括以下几个方面： 1. 线程的创建和启动：可以通过继承Thread类或实现Runnable接口来创建线程，并使用start()方法来启动线程。 2. 线程的生命周期：线程的生命周期包括新建、就绪、运行、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值