Java温故而知新-多线程

最新推荐文章于 2023-07-21 00:13:06 发布
最新推荐文章于 2023-07-21 00:13:06 发布
阅读量163 收藏 2
点赞数
分类专栏： java 笔记 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxyoucan/article/details/112462454
版权
java 同时被 2 个专栏收录
148 篇文章 4 订阅
订阅专栏
笔记
107 篇文章 1 订阅
订阅专栏

目录

线程与进程

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

windows下查CPU信息

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Thread类实现多线程

在这里插入图片描述
在这里插入图片描述

错误的代码🤣

直接调用run()方法是错误的！！！

class MyThread extends Thread { // 定义线程主体类
    private String name;

    public MyThread(String name) { // 设置一个名称
        this.name = name;
    }

    @Override   // 覆写父类中的方法
    public void run() { // 线程运行的主方法
        for (int x = 0; x < 10; x++) {
            System.out.println("【" + this.name + "】线程执行，当前的循环次数为：x = " + x);
        }
    }
}

public class A01错误的线程写法 {
    public static void main(String[] args) {
        MyThread threadA = new MyThread("Yootk-A线程");  // 线程类对象
        MyThread threadB = new MyThread("Yootk-B线程");  // 线程类对象
        MyThread threadC = new MyThread("Yootk-C线程");  // 线程类对象
        threadA.run();  // 线程主方法
        threadB.run();  // 线程主方法
        threadC.run();  // 线程主方法
    }
    
}

运行结果：

【Yootk-A线程】线程执行，当前的循环次数为：x = 0
【Yootk-A线程】线程执行，当前的循环次数为：x = 1
【Yootk-A线程】线程执行，当前的循环次数为：x = 2
【Yootk-A线程】线程执行，当前的循环次数为：x = 3
【Yootk-A线程】线程执行，当前的循环次数为：x = 4
【Yootk-A线程】线程执行，当前的循环次数为：x = 5
【Yootk-A线程】线程执行，当前的循环次数为：x = 6
【Yootk-A线程】线程执行，当前的循环次数为：x = 7
【Yootk-A线程】线程执行，当前的循环次数为：x = 8
【Yootk-A线程】线程执行，当前的循环次数为：x = 9
【Yootk-B线程】线程执行，当前的循环次数为：x = 0
【Yootk-B线程】线程执行，当前的循环次数为：x = 1
【Yootk-B线程】线程执行，当前的循环次数为：x = 2
【Yootk-B线程】线程执行，当前的循环次数为：x = 3
【Yootk-B线程】线程执行，当前的循环次数为：x = 4
【Yootk-B线程】线程执行，当前的循环次数为：x = 5
【Yootk-B线程】线程执行，当前的循环次数为：x = 6
【Yootk-B线程】线程执行，当前的循环次数为：x = 7
【Yootk-B线程】线程执行，当前的循环次数为：x = 8
【Yootk-B线程】线程执行，当前的循环次数为：x = 9
【Yootk-C线程】线程执行，当前的循环次数为：x = 0
【Yootk-C线程】线程执行，当前的循环次数为：x = 1
【Yootk-C线程】线程执行，当前的循环次数为：x = 2
【Yootk-C线程】线程执行，当前的循环次数为：x = 3
【Yootk-C线程】线程执行，当前的循环次数为：x = 4
【Yootk-C线程】线程执行，当前的循环次数为：x = 5
【Yootk-C线程】线程执行，当前的循环次数为：x = 6
【Yootk-C线程】线程执行，当前的循环次数为：x = 7
【Yootk-C线程】线程执行，当前的循环次数为：x = 8
【Yootk-C线程】线程执行，当前的循环次数为：x = 9

在这里插入图片描述

正确的写法

 public static void main(String[] args) {
        MyThread threadA = new MyThread("Yootk-A线程");  // 线程类对象
        MyThread threadB = new MyThread("Yootk-B线程");  // 线程类对象
        MyThread threadC = new MyThread("Yootk-C线程");  // 线程类对象
        threadA.start();  // 启动线程并调用run()方法
        threadB.start();  // 启动线程并调用run()方法
        threadC.start();  // 启动线程并调用run()方法
    }

运行结果：

【Yootk-B线程】线程执行，当前的循环次数为：x = 0
【Yootk-C线程】线程执行，当前的循环次数为：x = 0
【Yootk-A线程】线程执行，当前的循环次数为：x = 0
【Yootk-A线程】线程执行，当前的循环次数为：x = 1
【Yootk-C线程】线程执行，当前的循环次数为：x = 1
【Yootk-C线程】线程执行，当前的循环次数为：x = 2
【Yootk-C线程】线程执行，当前的循环次数为：x = 3
【Yootk-C线程】线程执行，当前的循环次数为：x = 4
【Yootk-C线程】线程执行，当前的循环次数为：x = 5
【Yootk-C线程】线程执行，当前的循环次数为：x = 6
【Yootk-C线程】线程执行，当前的循环次数为：x = 7
【Yootk-C线程】线程执行，当前的循环次数为：x = 8
【Yootk-C线程】线程执行，当前的循环次数为：x = 9
【Yootk-B线程】线程执行，当前的循环次数为：x = 1
【Yootk-B线程】线程执行，当前的循环次数为：x = 2
【Yootk-A线程】线程执行，当前的循环次数为：x = 2
【Yootk-A线程】线程执行，当前的循环次数为：x = 3
【Yootk-B线程】线程执行，当前的循环次数为：x = 3
【Yootk-B线程】线程执行，当前的循环次数为：x = 4
【Yootk-B线程】线程执行，当前的循环次数为：x = 5
【Yootk-A线程】线程执行，当前的循环次数为：x = 4
【Yootk-A线程】线程执行，当前的循环次数为：x = 5
【Yootk-A线程】线程执行，当前的循环次数为：x = 6
【Yootk-A线程】线程执行，当前的循环次数为：x = 7
【Yootk-A线程】线程执行，当前的循环次数为：x = 8
【Yootk-A线程】线程执行，当前的循环次数为：x = 9
【Yootk-B线程】线程执行，当前的循环次数为：x = 6
【Yootk-B线程】线程执行，当前的循环次数为：x = 7
【Yootk-B线程】线程执行，当前的循环次数为：x = 8
【Yootk-B线程】线程执行，当前的循环次数为：x = 9

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Runnable

在这里插入图片描述
在这里插入图片描述

class MyThread implements Runnable { // 定义线程主体类
    private String name ;
    public MyThread(String name) { // 设置一个名称
        this.name = name ;
    }
    @Override   // 覆写父类中的方法
    public void run() { // 线程运行的主方法
        for (int x = 0 ; x < 1000 ; x ++) {
            System.out.println("【" + this.name + "】线程执行，当前的循环次数为：x = " + x);
        }
    }
}
public class Runnable多线程 {
    public static void main(String[] args) {
        MyThread threadA = new MyThread("Yootk-A线程") ;  // 线程类对象
        MyThread threadB = new MyThread("Yootk-B线程") ;  // 线程类对象
        MyThread threadC = new MyThread("Yootk-C线程") ;  // 线程类对象
        new Thread(threadA).start();  // 启动线程并调用run()方法
        new Thread(threadB).start();  // 启动线程并调用run()方法
        new Thread(threadC).start();  // 启动线程并调用run()方法
    }
}

Lambda写法

public class Lambda简写 {
    public static void main(String[] args) {
        for (int x = 0 ; x < 3 ; x ++) {
            String name = "Yootk-" + x + "线程对象" ;
            new Thread(()->{
                for (int y = 0 ; y < 10 ; y ++) {
                    System.out.println("【" + name + "】线程执行，当前的循环次数为：num = " + y);
                }
            }).start(); // 启动多线程
        }
    }
}

这种写法简单多了，就感觉跟写ES6语法差不多。

在这里插入图片描述

Runnable与Thread的关系

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

卖票程序演示

package com.yootk.demo;

class MyThread implements Runnable { // 定义线程主体类
    private int ticket = 5 ; // 一共要卖5张票
    @Override   // 覆写父类中的方法
    public void run() { // 线程运行的主方法
        while (this.ticket > 0) {   // 编写一个循环
            if (this.ticket > 0) {  // 判断是否有剩余的票数
                System.out.println("【卖票】ticket = " + this.ticket --); // 卖票处理
            } else { // 结束循环
                break ;
            }
        }
    }
}
public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) {
        MyThread myThread = new MyThread() ; // 创建Runnable接口对象
        // Runnable如果要想进行启动则必须依靠Thread类，而在Thread类里面提供有一个target的属性。
        Thread threadA = new Thread(myThread) ; // 创建Thread类的对象实例
        Thread threadB = new Thread(myThread) ; // 创建Thread类的对象实例
        Thread threadC = new Thread(myThread) ; // 创建Thread类的对象实例
        threadA.start();    // 启动多线程，所有的操作都针对于同一个target对象实例完成
        threadB.start();    // 启动多线程，所有的操作都针对于同一个target对象实例完成
        threadC.start();    // 启动多线程，所有的操作都针对于同一个target对象实例完成
    }
}

在这里插入图片描述

Thread方式实现

在这里插入图片描述

package com.yootk.demo;

class MyThread extends Thread { // 定义线程主体类
    private int ticket = 5 ; // 一共要卖5张票
    @Override   // 覆写父类中的方法
    public void run() { // 线程运行的主方法
        while (this.ticket > 0) {   // 编写一个循环
            if (this.ticket > 0) {  // 判断是否有剩余的票数
                System.out.println("【卖票】ticket = " + this.ticket --); // 卖票处理
            } else { // 结束循环
                break ;
            }
        }
    }
}
public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) {
        MyThread myThread = new MyThread() ; // 创建Runnable接口对象
        // Runnable如果要想进行启动则必须依靠Thread类，而在Thread类里面提供有一个target的属性。
        Thread threadA = new Thread(myThread) ; // 创建Thread类的对象实例
        Thread threadB = new Thread(myThread) ; // 创建Thread类的对象实例
        Thread threadC = new Thread(myThread) ; // 创建Thread类的对象实例
        threadA.start();    // 启动多线程，所有的操作都针对于同一个target对象实例完成
        threadB.start();    // 启动多线程，所有的操作都针对于同一个target对象实例完成
        threadC.start();    // 启动多线程，所有的操作都针对于同一个target对象实例完成
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Callable

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

package com.yootk.demo;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;

class MyThread implements Callable<String> { // 返回值类型为String
    @Override   // 覆写父类中的方法
    public String call() { // 线程运行的主方法
        String result = "" ; // 保存返回结果
        for (int x = 0 ; x < 10 ; x ++) {   // 执行一个数据的循环操作
            result += "沐言科技：www.yootk.com\n" ; // 循环修改字符串内容，不去考虑性能问题
        }
        return result ;
    }
}
public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        MyThread myThread = new MyThread() ; // 创建Callable接口对象
        FutureTask<String> future = new FutureTask<>(myThread) ; // 包装了Callable接口对象
        Thread thread = new Thread(future) ; // 通过Thread创建线程对象
        thread.start();  // 启动多线程
        System.out.println(future.get()); // 异步获取
    }
}

运行结果：
沐言科技：www.yootk.com
沐言科技：www.yootk.com
沐言科技：www.yootk.com
沐言科技：www.yootk.com
沐言科技：www.yootk.com
沐言科技：www.yootk.com
沐言科技：www.yootk.com
沐言科技：www.yootk.com
沐言科技：www.yootk.com
沐言科技：www.yootk.com

在这里插入图片描述
在这里插入图片描述
什么是JUC
在这里插入图片描述

生命周期

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

线程的休眠

在这里插入图片描述
在这里插入图片描述

package com.yootk.demo;

public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        for (int x = 0; x < 10; x++) {
            new Thread(() -> {
                for (int y = 0; y < 100; y++) {
                    try {
                        Thread.sleep(1000); // 延迟1秒执行
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("【" + Thread.currentThread().getName() + "】num = " + y);
                }
            }, "Yootk线程 - " + x).start(); // 线程启动
        }
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

线程中断

在这里插入图片描述
在这里插入图片描述

package com.yootk.demo;

public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(()->{
            try {
                System.out.println("【"+Thread.currentThread().getName()+"】准备进入到休眠状态，预计的休眠时间为20秒 ...");
                Thread.sleep(20000);    // 需要休眠20秒的时间
                System.out.println("【"+Thread.currentThread().getName()+"】休眠状态正常结束 ...");
            } catch (InterruptedException e) {  // 线程被中断就会产生中断异常
                System.out.println("【"+Thread.currentThread().getName()+"】休眠产生了异常，无法正常完成休眠处理 ...");
            }
        }, "休眠线程") ; // 创建一个线程类
        thread.start(); // 启动多线程
        System.out.println("【中断状态】" + thread.isInterrupted());
        Thread.sleep(2000); // 让线程对象适当的执行一段时间
        thread.interrupt(); // 打断当前线程的休眠状态
        System.out.println("【中断状态】" + thread.isInterrupted());
    }
}

在这里插入图片描述

线程的强制执行

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

package com.yootk.demo;

public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        Thread mainThread = Thread.currentThread(); // 获取当前的主线程
        Thread joinThread = new Thread(() -> {
            for (int x = 0; x < 10000; x++) {  // 将持续执行循环代码
                try {
                    Thread.sleep(100); // 追加一个延迟
                    if (x >= 10) {  // 设置一个处理条件
                        mainThread.join();  // 子线程要交出全部的资源给主线程
                    }
                    System.out.println("〖" + Thread.currentThread().getName() + "〗子线程执行，x = " + x);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "工作线程"); // 创建一个线程类
        joinThread.start(); // 启动子线程
        for (int x = 0; x < 30; x++) {
            Thread.sleep(100); // 追加一个延迟
            System.out.println("【" + Thread.currentThread().getName() + "】主线程执行，x = " + x);
        }
    }
}

在这里插入图片描述

线程同步

在这里插入图片描述

在这里插入图片描述

线程死锁

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

生产者与消费者模型

在这里插入图片描述

在这里插入图片描述

生产者与消费者模型的实现类结构

在这里插入图片描述

package com.yootk.demo;
class Message { // 描述一个公共空间
    private String title ;  // 描述信息的标题
    private String content ;  // 描述信息的内容
    public void setTitle(String title) {
        this.title = title;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public String getTitle() {
        return title;
    }
    public String getContent() {
        return content;
    }
}
class ProducerThread implements Runnable {
    private Message message ; // 获取Message的引用
    public ProducerThread(Message message) {
        this.message = message ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 50 ; x ++) {   // 生产50次的信息
            try {
                if (x % 2 == 0) {
                    this.message.setTitle("李兴华编程训练营");
                    Thread.sleep(100);
                    this.message.setContent("yootk.ke.qq.com");
                } else {
                    this.message.setTitle("沐言科技");
                    Thread.sleep(100);
                    this.message.setContent("www.yootk.com");
                }
            } catch (Exception e) {}
        }
    }
}
class ConsumerThread implements Runnable {
    private Message message ; // 获取Message的引用
    public ConsumerThread(Message message) {
        this.message = message ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 50 ; x ++) {   // 获取50次的信息
            System.out.println("【消费者】title = " + this.message.getTitle() + "、content = " + this.message.getContent());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        Message message = new Message() ; // 实例化Message
        new Thread(new ProducerThread(message)).start(); // 启动生产者线程
        new Thread(new ConsumerThread(message)).start(); // 启动消费者线程
    }
}

在这里插入图片描述

数据同步处理

在这里插入图片描述

package com.yootk.demo;
class Message { // 描述一个公共空间
    private String title ;  // 描述信息的标题
    private String content ;  // 描述信息的内容
    public synchronized void set(String title, String content) {
        this.title = title ;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content = content ;
    }
    public synchronized String get() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "title = " + this.title + "、content = " + this.content ;
    }
}
class ProducerThread implements Runnable {
    private Message message ; // 获取Message的引用
    public ProducerThread(Message message) {
        this.message = message ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 50 ; x ++) {   // 生产50次的信息
            try {
                if (x % 2 == 0) {
                    this.message.set("李兴华编程训练营", "yootk.ke.qq.com");
                } else {
                    this.message.set("沐言科技", "www.yootk.com");
                }
            } catch (Exception e) {}
        }
    }
}
class ConsumerThread implements Runnable {
    private Message message ; // 获取Message的引用
    public ConsumerThread(Message message) {
        this.message = message ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 50 ; x ++) {   // 获取50次的信息
            System.out.println("【消费者】" + this.message.get());
        }
    }
}
public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        Message message = new Message() ; // 实例化Message
        new Thread(new ProducerThread(message)).start(); // 启动生产者线程
        new Thread(new ConsumerThread(message)).start(); // 启动消费者线程
    }
}

解决线程重复的操作问题

在这里插入图片描述

在这里插入图片描述

package com.yootk.demo;
class Message { // 描述一个公共空间
    private String title ;  // 描述信息的标题
    private String content ;  // 描述信息的内容
    private boolean flag = true ; // 设置一个标志位（红绿灯控制）
    // flag = true：表示可以生产，但是却无法进行消费（如果此时是由消费线程获取操作，则消费线程要等待）
    // flag = false：表示可以消费，但是无法生产（如果此时是由生产线程获取操作，则生产线程要等待）
    public synchronized void set(String title, String content) {
        if (this.flag == false) {   // 不允许生产，但是允许消费
            try {   // 此时的生产者线程暂停执行
                super.wait(); // 等待消费者线程执行完毕后唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 如果执行了如下的代码则表示允许进行生产，但是生产的最后需要唤醒等待的消费线程
        this.title = title ;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content = content ;
        this.flag = false ; // 修改标志位，表示生产完成，可以消费
        super.notify(); // 唤醒其他等待线程
    }
    public synchronized String get() {
        if (this.flag == true) {    // 不允许消费，只允许生产
            try {   // 此时的消费者线程暂停执行
                super.wait(); // 等待消费者线程执行完毕后唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 如果执行了如下的代码则表示允许进行消费，但是消费的最后需要唤醒等待的生产线程
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.flag = true ; // 修改标志位，表示消费完成，可以生产
        super.notify(); // 唤醒其他等待线程
        return "title = " + this.title + "、content = " + this.content ;
    }
}
class ProducerThread implements Runnable {
    private Message message ; // 获取Message的引用
    public ProducerThread(Message message) {
        this.message = message ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 50 ; x ++) {   // 生产50次的信息
            try {
                if (x % 2 == 0) {
                    this.message.set("李兴华编程训练营", "yootk.ke.qq.com");
                } else {
                    this.message.set("沐言科技", "www.yootk.com");
                }
            } catch (Exception e) {}
        }
    }
}
class ConsumerThread implements Runnable {
    private Message message ; // 获取Message的引用
    public ConsumerThread(Message message) {
        this.message = message ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 50 ; x ++) {   // 获取50次的信息
            System.out.println("【消费者】" + this.message.get());
        }
    }
}
public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        Message message = new Message() ; // 实例化Message
        new Thread(new ProducerThread(message)).start(); // 启动生产者线程
        new Thread(new ConsumerThread(message)).start(); // 启动消费者线程
    }
}

在这里插入图片描述

在这里插入图片描述

优雅的停止线程

在这里插入图片描述

package com.yootk.demo;
class Message implements Runnable {
    private boolean stopFlag = false ; // 停止标记
    @Override
    public void run() {
        for (int x = 0; x < 1000; x++) {
            if (this.stopFlag) {    // 如果内容为true，则退出循环
                break; // 退出整个的循环
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("【Mesasge信息输出 － " + x + "】沐言科技：www.yootk.com");
        }
    }
    public void stop() {
        this.stopFlag = true ; // 修改停止标志
    }
}
public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        Message message = new Message() ; // 实例化Message
        new Thread(message).start(); // 启动线程
        Thread.sleep(2000); // 让线程先运行2秒的时间
        message.stop();
    }
}

在这里插入图片描述

守护线程

package com.yootk.demo;
class Message implements Runnable {
    public Message() {  // 构造方法
        Thread daemonThread = new Thread(()->{
            for (int x = 0 ; x < Integer.MAX_VALUE ; x ++) {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("〖守护线程〗李兴华编程训练营：yootk.ke.qq.com");
            }
        }) ;
        daemonThread.setDaemon(true); // 设置为守护线程
        daemonThread.start(); // 守护线程启动
    }
    @Override
    public void run() {
        for (int x = 0; x < 10; x++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("【Message信息输出】沐言科技：www.yootk.com");
        }
    }
}
public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        Message message = new Message() ; // 实例化Message
        new Thread(message).start(); // 启动线程
    }
}

volatile

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.yootk.demo;
class TicketThread implements Runnable {
    private volatile int ticket = 3 ; // 一共卖3张票
    @Override
    public void run() {
        while (this.sale()) {
            ;
        }
    }
    public synchronized boolean sale() {
        if (this.ticket > 0 ) { // 有票就卖
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("【" + Thread.currentThread().getName() + "】售票，剩余票数为，ticket = " + (--this.ticket));
            return true ;
        }
        return false ;
    }
}
public class YootkDemo {    // 李兴华编程训练营：yootk.ke.qq.com
    public static void main(String[] args) throws Exception {
        TicketThread threadBody = new TicketThread() ;
        new Thread(threadBody, "票贩子-A").start();
        new Thread(threadBody, "票贩子-B").start();
        new Thread(threadBody, "票贩子-C").start();
    }
}

学习心得

在这个CPU单核性能发展出现瓶颈，CPU的发展越来越向多核发展的时代。
多线程的开发非常重要，最简单有较的提高程序的执行效率。可以有较的充分利用现在的硬件资源。

ITKEY_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java多线程设计模式
07-25
《JAVA多线程设计模式》中包含JAVA线程的介绍导读，12个重要的线程设计模式和全书总结以及丰富的...最后附上练习问题，让读者可以温故而知新，能快速地吸收书中的精华，书中最后附上练习问题解答，方便读者学习验证。
java多线程设计模式详解(PDF及源码)
07-14
最后附上练习问题，让读者可以温故而知新，能快速地吸收书中的精华，书中最后附上练习问题解答，方便读者学习验证。 目录 漫谈UML UML 类图 类和层次结构的关系 接口与实现 聚合 访问控制 类间的关联性 顺序图 处理...
温故而知新-多线程
t943044085的博客
11-21 82
多线程相关理论 1.通常一个java程序运行之后是一个进程（最少包含一个线程MAIN线程），一个进程可以包含多个线程。 线程的创建方式 1.继承Thread类,运行thread.start() 2.实现Runnable接口 3.实现Callable接口 继承Thread类和实现Runable接口的区别是实现接口更加方便,避免了继承的局限性,并且方便对任务进行不同的封装. Callable可以抛出异常并获取返回值. 线程的五大状态 创建-就绪（等待CPU调度）-运行 -阻塞（sleep或wait等）-死
Java温故而知新-日期时间
lxyoucan的博客
01-21 200
目录Date类Date实例化与日期比较Calendar范例：获取当前日期时间范例：日期计算范例：找到8月的最后一天SimpleDateFormat范例：日期格式化yyyy-MM-dd HH:mm:ss.SSS范例：字符串转日期时间（String ➡️ Date）数据类型转换表LocalDate范例：获取当年的日期时间范例：通过LocalDate获取详细的日期数据范例：判断是否是闰年范例：日期的推算多线程中日期格式化方式一：性能差，容易产生垃圾方式二：多线程会报错方式三：DateTimeFormatter（
Java温故而知新-管道流
lxyoucan的博客
03-17 130
管道流 Java本身是属于多纯种的编程语言，而多线程和多进程最大的区别在于：一个进程可以产生多个线程，那么这些线程都属于同一个进程中的组成单元，所以这些线程都可以直接共享给定进程里面的所有资源，包括数据，但是在Java里面它强调不同的线程有可能也有属于自己的内容，所以不同线程之间也应该利用管道的方式来进行处理。 Java代码： package com.yootk.demo; import java.io.IOException; import java.io.PipedInputStream; impor
Java温故而知新-UUID类、Optional类、ThreadLocal
lxyoucan的博客
01-21 99
UUID public static void main(String[] args) throws Exception { String id = UUID.randomUUID().toString() ; // 生成UUID数据 System.out.println(id); } Optional 不用Optional时处理null package com.yootk.demo; interface IMessage { // 定义一个接口 publ
【温故而知新】多线程基本知识
大壮的博客
04-27 232
多线程面试47题 1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 3）有序性 有序性，即程序的执行顺序按照代码的先后顺序来执行。 2、实现可见性的方法有哪些？ synchroni...
温故而知新-JVM垃圾收集器
Handoking的博客【学无止境】
07-21 417
现在垃圾收集器均采用分代收集策略，新生代由于98%的对象都是朝生夕死，复制算法更合适，只复制还存活的对象，工作量小，所以效率高。显然复制算法不适合老年代，因为老年代中的对象大部分是大对象，且长时间存活，复制算法效率太低。老年代使用标记-清除，标记-整理算法更合适。c. 对CPU资源敏感。默认启动的线程 （CPU+3）/4，在CPU较少时，占用较多资源，影响用户线程资源。b. 无法收集浮动垃圾（浮动：并发清除过程中新产生待标记的对象）a. 标记-清除导致内存碎片太多，容易引起full-gc。
《温故而知新系列》JAVA多线程之Volatile关键字
m0_56437092的博客
10-21 271
但是线程对变量的操作（读取赋值等）必须的自已的工作内存中进行，首先要将主内存中的变量拷贝到自已的工作内存中来，然后对变量进行操作，操作完成后在将变量写回主内存，被volatile修饰的变量被修改时，会将修改后的变量直接写入主存中，并且将其他线程中该变量的缓存置为无效，从而让其它线程对该变量的引用直接从主存中获取数据，这样就保证了变量的可见性。
温故而知新！java多线程和cpu的线程区别
m0_57699613的博客
07-01 212
Kubernetes（k8s）理论与实战双飞 ①理解控制器： ②网络详解： ③伸缩原理： ④认证与调度： ⑤服务原理： ⑥镜像自动拉取： ⑦节点就绪问题之一： ⑧节点就绪问题之二： ⑨命名空间删除问题： ⑩集群安全组配置管理： ⑪二分之一活的微服务： ⑫服务网格证书过期问题： Docker步步实践，入门到入坟 目录文档： ①Docker简介 ②基本概念 ③安装Docker ④使用镜像： ⑤操作容器： ⑥访问仓库： ⑦数据管理： ⑧使用网络： ⑨高级网络配置： ⑩安全
温故而知新(5)-Java基础之线程的使用
小糖豆
12-09 122
前言 一个应用程序可能有多个进程，一个进程可能有多个线程，多线程并非同时进行，而是充分利用cpu的资源，因为其切换时间很短，所以直观上认为是并行的。 创建线程的两种方式 不管是哪种方式，都需要重写run方法，所有的业务处理都在这里 继承Thread 自定义线程类： public class MyThread extends Thread { //定义指定线程名称的构造方法 public MyThread(String name) { super(name); //调用父类的Strin
java多线程设计模式及源码
01-24
多线程与并发处理是程序设计好坏优劣的重要课题，本书通过浅显易懂的文字与实例来介绍JAVA线程相关...最后附上练习问题，让读者可以温故而知新，能快速地吸收书中的精华，书中最后附上练习问题解答，方便读者学习验证。
JAVA多线程设计模式（带完整书签清晰扫描版）
03-21
《JAVA多线程设计模式》中包含JAVA线程的介绍导读，12个重要的线程设计模式和全书总结以及丰富的...最后附上练习问题，让读者可以温故而知新，能快速地吸收书中的精华，书中最后附上练习问题解答，方便读者学习验证。
RuoYi若依打包发布与部署
热门推荐
lxyoucan的博客
04-04 4万+
上一节我们已经讲过了如果搭建开发环境，那么如果代码写完了，如何打包发布。部署到生产环境呢？ 《RuoYi开发实战-搭建开发环境》 https://blog.csdn.net/lxyoucan/article/details/123764953 环境 我先说一下我的环境信息： 开发环境： 操作系统：macOS BigSur 11.4 开发工具：IDEA 2021.1 后台打包 在RuoYi-Vue项目的根目录执行以下命令。 mvn clean package -Dmaven.test.skip=true
IDEA官方历史版本下载
lxyoucan的博客
12-24 2万+
Version 2021.2以后的版本，就要登录账号了。感觉不太方便。还要注册一个账号才行，所以我想下载历史版本，不需要登录账号也可以使用的。 IDEA官方历史版本下载 https://www.jetbrains.com/idea/download/other.html ...
若依框架登录去除验证码
lxyoucan的博客
04-06 1万+
若依框架自带的登录功能还是挺好用的。但是在开发过程中经过因在编写代码或者编写设计文档登录会话到期重新登录。重新登录就会出现验证码，一天如果要输入10次验证码也会浪费不少时间。 验证码这个功能在生产环境非常有必要，但是在开发模式完全没有价值。 如何关掉验证码功能呢？ admin用户登录 系统管理->参数设置->账号自助-验证码开关 设置成false 这样重新登录就没有验证码显示了。 使用sql操作 #关闭验证码 update sys_config set config_value='fal.
Spring boot redis java.io.IOException: 远程主机强迫关闭了一个现有的连接
lxyoucan的博客
05-17 1万+
现象 在测试环境部署的若依版本，经常会报如下的错误。而我在开发环境基本没有遇到过。 16:38:01.040 [lettuce-nioEventLoop-4-2] INFO i.l.c.p.CommandHandler - [log,217] - null Unexpected exception during request: java.io.IOException: 远程主机强迫关闭了一个现有的连接。 java.io.IOException: 远程主机强迫关闭了一个现有的连接。 at sun.nio
【视频】RuoYi开发实战-搭建开发环境
lxyoucan的博客
04-01 8944
简介 RuoYi 使用若依快速构建web应用程序 http://doc.ruoyi.vip/ 特点 最新技术栈 使用最流行的技术SpringBoot、SpringCloud、Shiro、Thymeleaf、Vue、Element、Bootstrap。 前后端分离 提供前后端分离的版本：使用的前端技术Vue、Element后端SpringBoot & Security完全分离的权限管理系统。 微服务版本 提供微服务架构的版本：使用的前端技术Vue、Element、后端Spring Clou
用英文对话的方式回答下列三个问题：1.大学生如何理解温故而知新，2.学生如何更好地去复习，3.温故而知新的过程需要注意什么
最新发布
08-16
大学生理解温故而知新意味着要在学习新知识之前，先回顾和复习以前学过的相关知识或基础知识。通过温故，我们能够加深对已有知识的理解和记忆，从而更好地理解和掌握新的知识。 2. 学生如何更好地去复习？ 学生要更...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值