多线程实现

1.多线程：并发实现

主线程和子线程并行实现。

一个进程中有多个线程，可以同时进行多个任务。进程是系统分配的，线程的执行是由调度器决定的。

注意：线程开启不一定执行，由Cpu调度执行。

线程创建的三种方式：

Thread 类型:

子类继承Thread类，并重写了run方法，然后实例化子类然后调用start（）方法。 会让多个子线程同时进行。

package com;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 8:49
 * @project Chapter01_Java_多线程
 **/


/*
    1. 实现线程的第一种方式： 集成Thread类
    2. 然后new一个子类的对象，然后调用start方法；
 */
public class ThreadTest01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println(i+"--我在写代码");
        }
    }

    //主线程main 和子线程threadTest01同时执行；
    public static void main(String[] args) {
        ThreadTest01 threadTest01 = new ThreadTest01();
        threadTest01.start();

        for (int i = 0; i <200 ; i++) {
            System.out.println(i+"**我在看书，别打扰我");
        }
    }

}

0**我在看书，别打扰我
1**我在看书，别打扰我
2**我在看书，别打扰我
3**我在看书，别打扰我
4**我在看书，别打扰我
5**我在看书，别打扰我
6**我在看书，别打扰我
7**我在看书，别打扰我
8**我在看书，别打扰我
9**我在看书，别打扰我
10**我在看书，别打扰我
11**我在看书，别打扰我
12**我在看书，别打扰我
13**我在看书，别打扰我
0--我在写代码
1--我在写代码
2--我在写代码
3--我在写代码
4--我在写代码
5--我在写代码
6--我在写代码
14**我在看书，别打扰我
15**我在看书，别打扰我
16**我在看书，别打扰我
17**我在看书，别打扰我
18**我在看书，别打扰我

Runnable 接口: （推荐使用）

实现：实现Runnable接口，重写run方法。然后实例化一个Runnable接口对象类，再实例化一个Thread()类，传入Runnable类的实例化对象。最后调用start（）方法。

优势：避免单继承的局限性，可以一个对象被多个线程使用。

package com;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 9:02
 * @project Chapter01_Java_多线程
 **/

/** 1. 实现Runnable接口，并重写run方法
    2. 实例化runnbale的子类，传入到Thread实例化类种，并调用start方法；
*/
public class RunnableTest01 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println(i+"--我在写代码");
        }
    }
    public static void main(String[] args) {

        RunnableTest01 runnableTest01 = new RunnableTest01();
        new Thread(runnableTest01).start();//传入runnable的实例化，调用start方法

        for (int i = 0; i <500 ; i++) {
            System.out.println(i+"***我在看书，别打扰我");
        }
    }
}



0***我在看书，别打扰我
0--我在写代码
1***我在看书，别打扰我
1--我在写代码
2***我在看书，别打扰我
2--我在写代码
3***我在看书，别打扰我
3--我在写代码
4***我在看书，别打扰我
4--我在写代码
5***我在看书，别打扰我
5--我在写代码
6***我在看书，别打扰我
6--我在写代码
7***我在看书，别打扰我
7--我在写代码
8***我在看书，别打扰我
9***我在看书，别打扰我
10***我在看书，别打扰我
11***我在看书，别打扰我
12***我在看书，别打扰我
13***我在看书，别打扰我
14***我在看书，别打扰我
15***我在看书，别打扰我
16***我在看书，别打扰我
17***我在看书，别打扰我

问题：并发条件下，多线程同时访问一个资源，会造成数据紊乱，出现一个资源被多个人占用的问题。典型的买票。
package com;

import javax.swing.plaf.synth.SynthOptionPaneUI;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 9:10
 * @project Chapter01_Java_多线程
 **/
public class RunnabTest02 implements Runnable{

    private int ticket=10;
    @Override
    public void run() {
      while (true){
          if (ticket<=0){
              break;
          }
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName()+"买了第"+ticket--+"张票");
      }
    }

    public static void main(String[] args) {
        //一份资源
        RunnabTest02 runnabTest02 = new RunnabTest02();
        //可以有多个代理：实现
        new Thread(runnabTest02,"小明").start();
        new Thread(runnabTest02,"小芳").start();
        new Thread(runnabTest02,"黄牛党").start();
    }
}

龟兔赛跑的例子：

package com;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 9:39
 * @project Chapter01_Java_多线程
 **/
public class Race implements Runnable {
    private stadia

Callable 接口: （了解）：创建服务，提交服务，获取结果，关闭服务。

静态代理模式：
  1. 真实对象和代理对象都要实现同一个接口
  2. 代理对象代理真实对象，真实对象只用做自己的事情，不用分心。

好处：代理对象可以做很多真实对象做不了的事情，而真实对象只用专心做自己的事情。


package com;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 10:31
 * @project Chapter01_Java_多线程
 **/
public class StaticProxy {

    public static void main(String[] args) {
        //一样的结构： lamda表达式：
        new Thread(()-> System.out.println("线程开始")).start();
        new WeddingCompany(new Human()).happyMarry();
    }
}
//结婚的接口：
interface Marry{

    void happyMarry();//方法：
}

//真实对象
class Human implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("我要结婚了很开心");
    }
}

//代理对象：都实现Marry接口
class WeddingCompany implements Marry{
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void happyMarry() {
        before(); //结婚之前
        this.target.happyMarry();
        after(); //结婚之后
    }

    public void before(){
        System.out.println("结婚之前，布置现场");
    }

    public void after(){
        System.out.println("结婚之后，收尾款");
    }

}

Lambda表达式：让代码更加简洁，避免匿名内部类过多。
  1. lambda表达式只能由一行代码的情况下才能简化成一行，如果有多行的，那就使用代码块包裹。
  2. 为lambda表达式的前提是接口为函数式接口（就是只能有一个抽象的方法）
  3. 多个参数也可以去掉参数的类型，如果要去掉就都去掉。如果有多个参数就需要加上就都加上。
package com;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 11:39
 * @project Chapter01_Java_多线程
 **/
public class LambdaTest01 {
    // 2. 静态内部类实现：

    static class love2 implements iLike{
        @Override
        public void lambda(int a) {
            System.out.println(" i love you-->" + a);
        }
    }

    public static void main(String[] args) {
        //外部类
        iLike love = new love();
        love.lambda(2);
        
        //静态内部类：
        love2 love2 = new love2();
        love2.lambda(3);
        
        //3. 局部类：在一个类种还有一个类
        class love3 implements iLike{
            @Override
            public void lambda(int a) {
                System.out.println(" i love you-->" + a);
            }
        }
        love3 love3 = new love3();
        love3.lambda(4);
        // 4. 匿名内部类： 没有类的名称，只能由接口或者父类实现：
        iLike love4 = new iLike(){
            @Override
            public void lambda(int a) {
                System.out.println(" i love you-->" + a);
            }
        };
        love4.lambda(5);
        //5. lambda表达式实现：
        iLike love5=null;
        love5=(a)->{
            System.out.println(" i love you-->" + a);
        };
        love5.lambda(6);
        // 6. lambda简化：
        iLike love6=null;
        love6=a->{
            System.out.println(" i love you-->"+ a);
        };
        love6.lambda(7);
    }
}

interface iLike{
    void lambda(int a);
}
//1. 外部类实现：
class  love implements iLike{
    @Override
    public void lambda(int a) {
        System.out.println(" i love you-->" + a);
    }
}

线程停止：不使用JDK内置的stop，而是自己设置一个flag标志位进行线程的停止。
package com;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 12:13
 * @project Chapter01_Java_多线程
 **/
public class StopThread implements Runnable{
    //设置标志位：
    private  boolean flag=true;

    @Override
    public void run() {
        int i =0;
        while (flag) {
            System.out.println("子线程运行了"+i++ + "次");
        }
    }
    //外部停止的方法
    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        //创建线程
        StopThread thread1 = new StopThread();
        new Thread(thread1).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程运行了"+i+"次");
            if( i == 900){
                thread1.stop(); //让flag为false；子线程结束
                System.out.println("子线程运行结束");
            }
        }
    }

}

线程休眠：

Thread.sleep()方法。 每一个对象都有一把锁，sleep不会释放锁。

、package com;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 12:32
 * @project Chapter01_Java_多线程
 **/
public class ThreadSleep {

    public static void main(String[] args) throws InterruptedException {
        //模拟倒计时
        Date startTime = new Date(System.currentTimeMillis());
        while (true){
            //每次休眠1秒：
            Thread.sleep(1000);
            String time = new SimpleDateFormat("HH:mm:ss").format(startTime);
            System.out.println("当前系统时间为："+time);
            startTime= new Date(System.currentTimeMillis());

        }
    }
}

线程礼让：Thread.yield()方法；礼让不一定成功。

线程强制执行： Thread.join() 方法；
package com;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 13:16
 * @project Chapter01_Java_多线程
 **/
public class ThreadJoin {
    public static void main(String[] args) throws InterruptedException {
        VipThread vipThread=new VipThread();
        Thread thread = new Thread(vipThread);
        thread.start();

        //主线程：
        for (int i = 0; i < 500; i++) {
            //当主线程执行200次后，子线程进行插队操作；
            if (i==200){
              thread.join();//插队
            }
            System.out.println("主线程执行："+i+"次");
        }
    }
}

class VipThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("vip插队来了"+i);
        }
    }
}
观测线程状态：线程的五种状态：New 、Runnable、BLocked、Waiting、Time_waiting、terminated

线程一旦结束就不能重新开始！！！！！

package com;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 13:28
 * @project Chapter01_Java_多线程
 **/
public class ThreadState {

    public static void main(String[] args) throws InterruptedException {
        //子线程：
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("///");
        });

        Thread.State state = thread.getState();
        System.out.println("线程的当前状态是："+state);

        thread.start();//开始线程：
        
        state = thread.getState();
        System.out.println("线程的当前状态是："+state);
        
        
        //主线程
        //如果不是最后结束的状态：
        while (state != Thread.State.TERMINATED){
            Thread.sleep(1000);
            //更新线程状态：
            state=thread.getState();
            System.out.println("线程的当前状态是："+state);
        }

    }
}

线程的优先级：优先级高的可能先跑，但不一定会先跑。先设置线程，再start（）。一般是5，最高是10。

守护线程：

线程分为用户线程和守护线程。虚拟机必须要等待用户线程执行完毕，不用等待守护线程执行完毕。

package com;

/**
 * @author Lenovo
 * @date 2024/3/11
 * @time 13:59
 * @project Chapter01_Java_多线程
 **/
public class ThreadDemon {

    public static void main(String[] args) {
        God god = new God();
        user user = new user();
        
        //实现Runnable接口：
        Thread thread = new Thread(god);
        thread.setDaemon(true);
        //守护线程启动
        thread.start();

        //用户线程启动：
        new Thread(user).start();

    }
}

//守护线程
class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("守护线程保佑着你。。。");
        }
    }
}

//用户线程

class user implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 365000; i++) {
            System.out.println("我还活着");
        }
        System.out.println("结束吧，good bye world");
    }
}

思考

有什么想法或心得体会，都可以拿出来分享下。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/475403.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

js【详解】深拷贝

js【详解】深拷贝

什么是深拷贝&#xff1f; 对于引用类型的数据&#xff0c;才有深浅拷贝的说法 浅拷贝 &#xff1a;执行拷贝的变量只复制被拷贝变量内存的引用数据的地址。 被拷贝变量内地址指向的数据发生变化时&#xff0c;执行拷贝的变量也会同步改变 深拷贝&#xff1a; 在堆内存中开…
阅读更多...
高效输入关键词，瞬间生成惊艳图片：创意与速度的完美结合！

高效输入关键词，瞬间生成惊艳图片：创意与速度的完美结合！

在数字化时代&#xff0c;图片已经成为我们生活中不可或缺的一部分。无论是社交媒体的分享、广告的创意&#xff0c;还是工作中的报告展示&#xff0c;高质量的图片都能为我们的内容增添不少色彩。但你是否曾遇到过这样的困扰&#xff1a;想要一张符合心意的图片&#xff0c;却…
阅读更多...
VScode前端常用插件推荐

VScode前端常用插件推荐

Color Highlight—查看css颜色 这个插件可以让我们在vscode中看到代码中的颜色&#xff0c;效果如图所示 Chinese (Simplified) (简体中文) Language Pack for Visual Studi ------ 简体中文语言包 把vscode翻译为中文 Auto Rename Tag—自动修改对应的标签 效果如图所示…
阅读更多...
uniapp+uview实现城市选择器

uniapp+uview实现城市选择器

1.效果 2.代码—在components中创建CitySelect组件 <template><view><text class"uni-input" style"background-color: #F8F8F8;display: block;line-height: 76rpx;padding:0 29rpx;" tap"open">{{value}}</text><…
阅读更多...
01-java面试题八股文-----java基础——20题

01-java面试题八股文-----java基础——20题

文章目录 <font color"red">1、java语言有哪些特点&#xff1a;<font color"red">2、面向对象和面向过程的区别<font color"red">3、标识符的命名规则。<font color"red">4、八种基本数据类型的大小&#xff…
阅读更多...
linux下用docker安装mysql及导入文件

linux下用docker安装mysql及导入文件

目录 1. 非root用户设置docker权限2. user账号安装mysql2. root账号打开防火墙3. 启动mysql容器3.1 在指定工作目录下建立文件夹3.2 配置文件3.3 开启mysql容器 4. 进入容器4.1 通过容器进入mysql4.1 设置账号4.2 建立数据库4.3 导入文件 5. windows连接数据库参考文件 1. 非ro…
阅读更多...
.locked勒索病毒是什么，企业数据被加密了如何恢复？

.locked勒索病毒是什么，企业数据被加密了如何恢复？

.locked勒索病毒介绍 .locked勒索病毒是一种恶意软件&#xff0c;它利用加密技术锁定用户的数据或系统&#xff0c;并以此进行勒索。用户一旦感染此病毒&#xff0c;将无法访问其重要文件&#xff0c;病毒会要求用户支付一笔赎金以获取解密密钥。这种病毒通常使用强大的加密算法…
阅读更多...
ssm基于Vue.js的在线购物系统的设计与实现论文

ssm基于Vue.js的在线购物系统的设计与实现论文

摘 要 随着科学技术的飞速发展&#xff0c;各行各业都在努力与现代先进技术接轨&#xff0c;通过科技手段提高自身的优势&#xff1b;对于在线购物系统当然也不能排除在外&#xff0c;随着网络技术的不断成熟&#xff0c;带动了在线购物系统&#xff0c;它彻底改变了过去传统的…
阅读更多...
C#配置连接数据库字段

C#配置连接数据库字段

在Web.config文件中 添加如下配置 <!--连接数据库字段--><connectionStrings><add name"sql" connectionString"server.;uidsa;pwd8888;databaseArticleWebSite" /></connectionStrings>
阅读更多...
Harbor介绍

Harbor介绍

1.什么是Harbor Harbor是一个开源的企业级Docker Registry管理项目&#xff0c;由VMware公司开源。 Harbor提供了比Docker官方公共镜像仓库更为丰富和安全的功能&#xff0c;尤其适合企业环境使用。以下是Harbor的一些关键特性&#xff1a; 权限管理&#xff08;RBAC&#x…
阅读更多...
mysql 空间查询 多边形内的点

mysql 空间查询 多边形内的点

数据库查询 # 1新增空间point类型坐标字段 ALTER TABLE gaoxin_isdp.business_master ADD COLUMN location2 point NULL AFTER location;# 2从原字段更新点位字段&#xff0c;原字段poi1是字符串106.474596,29.464360 UPDATE business_master SET location POINT(substr(poi…
阅读更多...
BetterDisplay Pro：让屏幕管理更高效、更便捷

BetterDisplay Pro：让屏幕管理更高效、更便捷

BetterDisplay Pro是一款功能强大的显示器管理软件&#xff0c;适用于Windows和Mac操作系统。其主要功能包括显示器校准、自动校准、多种预设模式、手动校准以及可视化数据等。 具体而言&#xff0c;这款软件可以根据用户的需求和环境条件调整显示器的颜色、亮度和对比度等参数…
阅读更多...
YOLO改进模块出现的问题及改进方法

YOLO改进模块出现的问题及改进方法

1.grid_sampler_2d_backward_cuda 在对YOLOv9进行改进的过程中&#xff0c;有的时候就会出现这种报错&#xff1a;RuntimeError: grid_sampler_2d_backward_cuda does not have a deterministic implementation&#xff0c;but you set torch.use_deterministic_algorithms(Tr…
阅读更多...
免费阅读篇 | 芒果YOLOv8改进111：注意力机制CBAM：轻量级卷积块注意力模块，无缝集成到任何CNN架构中，开销可以忽略不计

免费阅读篇 | 芒果YOLOv8改进111：注意力机制CBAM：轻量级卷积块注意力模块，无缝集成到任何CNN架构中，开销可以忽略不计

&#x1f4a1;&#x1f680;&#x1f680;&#x1f680;本博客 改进源代码改进 适用于 YOLOv8 按步骤操作运行改进后的代码即可 该专栏完整目录链接&#xff1a; 芒果YOLOv8深度改进教程 该篇博客为免费阅读内容&#xff0c;YOLOv8CBAM改进内容&#x1f680;&#x1f680;&am…
阅读更多...
Sora的前世今生：从文生图到文生视频

Sora的前世今生：从文生图到文生视频

在2月16日凌晨&#xff0c;OpenAI首款文本生成视频模型Sora正式亮相&#xff0c;迅速在网络上引发广泛关注。对于Sora背后的技术原理&#xff0c;网络上已经充斥着各种分析和猜测&#xff0c;其中大多数分析都是从技术报告入手&#xff0c;对于普通读者来说难度相对较高。为了使…
阅读更多...
第 6 章 ROS-URDF练习(自学二刷笔记)

第 6 章 ROS-URDF练习(自学二刷笔记)

重要参考&#xff1a; 课程链接:https://www.bilibili.com/video/BV1Ci4y1L7ZZ 讲义链接:Introduction Autolabor-ROS机器人入门课程《ROS理论与实践》零基础教程 6.3.4 URDF练习 需求描述: 创建一个四轮圆柱状机器人模型&#xff0c;机器人参数如下&#xff0c;底盘为圆柱…
阅读更多...
HarmonyOS NEXT应用开发之跨文件样式复用和组件复用

HarmonyOS NEXT应用开发之跨文件样式复用和组件复用

介绍 本示例主要介绍了跨文件样式复用和组件复用的场景。在应用开发中&#xff0c;我们通常需要使用相同功能和样式的ArkUI组件&#xff0c;例如购物页面中会使用相同样式的Button按钮、Text显示文字&#xff0c;我们常用的方法是抽取公共样式或者封装成一个自定义组件到公共组…
阅读更多...
SpringBoot+Vue前后端分离项目在Linux系统中基于Docker打包发布

SpringBoot+Vue前后端分离项目在Linux系统中基于Docker打包发布

文章目录 SpringBootVue前后端分离项目在Linux系统中基于Docker打包发布一、Java项目基于Docker打包发布1.打包应用&#xff0c;将打好的jar包放到我们的linux系统中2.新建dockerfile3.打包镜像4.测试运行5.上传镜像到阿里云免费私仓 二、Vue项目打包到docker镜像1.编译打包前端…
阅读更多...
龙智亮相2024国际集成电路展览会暨研讨会（IIC Shanghai），分享芯片研发及管理解决方案与技术实践

龙智亮相2024国际集成电路展览会暨研讨会（IIC Shanghai），分享芯片研发及管理解决方案与技术实践

2024年3月28-29日&#xff08;周四-周五&#xff09;&#xff0c;上海张江科学会堂&#xff0c;2024国际集成电路展览会暨研讨会&#xff08;IIC Shanghai 2024&#xff09;即将盛大开幕。龙智携芯片研发及管理解决方案、最佳实践与案例&#xff0c;以及惊喜大奖在#1A14展位等着…
阅读更多...
Docker容器化技术（docker-compose示例:部署discuz论坛和wordpress博客，使用adminer管理数据库）

Docker容器化技术（docker-compose示例:部署discuz论坛和wordpress博客，使用adminer管理数据库）

安装docker-compose [rootservice ~]# systemctl stop firewalld [rootservice ~]# setenforce 0 [rootservice ~]# systemctl start docker[rootservice ~]# wget https://github.com/docker/compose/releases/download/v2.5.0/docker-compose-linux-x86_64创建目录 [rootse…
阅读更多...
最新文章

Copyright @ 2022~2023