javase-thread-210201-01

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量87 收藏
点赞数
分类专栏： javase 文章标签： java javase thread
白光一
本文链接：https://blog.csdn.net/FlyUp__/article/details/118378403
版权

javase-thread-210201-01

  • 简介
  • 创建线程
  • 练习
  • 静态代理模式

简介

  • 线程实现
  • 线程状态
  • 线程同步
  • 线程通信问题

操作系统中运行的程序就是进程，一个进程可以有多个线程

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念

进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位

通常在一个进程中可以包含若干个线程，一个进程中至少有一个线程（主线程），不然没有意义。线程是CPU调度和执行的单位。

注：很多线程是模拟出来的，真正的多线程是指由多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换很快，所以就有同时执行的错局。

  • 线程就是独立的执行路径
  • 在程序运行时，即使没有自己创建的线程，后台也会有多个线程，如主线程，gc线程
  • main()称主线程，为系统的入口，用于执行整个程序
  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
  • 对同一份资源进行操作时，会存在资源抢夺问题，需要加入并发控制
  • 线程会带来额外的开销，如cpu调度时间，并发控制开销
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

创建线程

1.Thread(类)
//继承Thread类
/*
	步骤：
		1.自定义线程类，继承Thread类
		2.重写run()方法，编写线程执行体
		3.创建线程对象，调用start()方法启动线程
*/

//线程开启不一定立即执行，由cpu调度执行

package bgy210310;

public class Demo01 extends Thread{

    // 重写 run() 方法
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {

            // 修改线程名称
            Thread.currentThread().setName("线程一");

            System.out.println("当前线程为" + Thread.currentThread().getName());

            // 线程睡眠
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        // 创建线程对象
        Demo01 demo01 = new Demo01();
        // 开启线程
        demo01.start();


        // 主线程
        for (int i = 0; i < 100; i++) {

            // 修改线程名称
            Thread.currentThread().setName("主线程");

            System.out.println("当前线程为" + Thread.currentThread().getName());
        }
    }
}
2.Runnable(接口)
/*
    1.定义Demo02类实现Runnable接口
    2.实现run()方法
    3.创建线程对象，调用start()方法，启动线程
*/

public class Demo02 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

            // 修改线程名称
            Thread.currentThread().setName("线程一");

            System.out.println("当前线程为" + Thread.currentThread().getName());

            // 线程睡眠
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
//        Demo02 demo02 = new Demo02();
//        Thread thread = new Thread(demo02);       // 代理模式
//        thread.start();

//        Thread thread = new Thread(new Demo02());
//        thread.start();

        // 创建线程并启动
        new Thread(new Demo02()).start();

        // 主线程
        for (int i = 0; i < 100; i++) {

            // 修改线程名称
            Thread.currentThread().setName("主线程");

            System.out.println("当前线程为" + Thread.currentThread().getName());
        }
    }
}
3.Callable(接口)
/*
    1.实现 Callable 接口
    2.重写call方法，，需要抛出异常，并且需要一个返回值
    3.创建目标对象
    4.创建执行服务     ExecutorService service = Executors.newFixedThreadPool();
    5.提交执行        Future<Boolean> r = service.submit();
    6.获取结果        boolean rs = r.get();
    7.关闭服务        service.shutdown();
 */

public class Demo03 implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("当前线程为" + Thread.currentThread().getName());

            // 线程睡眠
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建目标对象
        Demo03 demo03_01 = new Demo03();
        Demo03 demo03_02 = new Demo03();

        // 创建执行服务
        // 参数是 你想有几个线程，就来几个，我目前是2个线程，，就是2
        ExecutorService service = Executors.newFixedThreadPool(2);

        // 提交执行
        Future<Boolean> r1 = service.submit(demo03_01);
        Future<Boolean> r2 = service.submit(demo03_02);

        // 获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();

        // 关闭服务
        service.shutdown();
    }
}

练习

买票问题
/*
	出现问题：
		多个线程操作同一个资源的情况下，出现了线程不安全
*/

public class Demo04 implements Runnable{
    // 目前有30张票
    public int numTicket = 30;

    @Override
    public void run() {
        while (true){
            if(numTicket <= 0){
                System.out.println("票以售空");
                break;
            }

            // 模拟买票延时
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "拿到第" + numTicket-- + "张票");
        }
    }

    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        new Thread(demo04,"小明").start();
        new Thread(demo04,"王刚").start();
        new Thread(demo04,"黄牛").start();
    }
}
龟兔赛跑
public class Demo05 implements Runnable{
    private int distance = 100;
    private String winner;

    @Override
    public void run() {
        for (int i = distance; i >= 0; i--) {

            // 模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子")){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 判断比赛是否结束
            boolean flag = isOver(i);
            if (flag){
                break;
            }

            System.out.println(Thread.currentThread().getName() + "还剩" + i + "米");
        }
    }

    // 判断是否跑完路程
    public boolean isOver(int distance){
        // 已经存在获胜者
        if (winner != null){
            return true;
        }
        if (distance <= 0){
            winner = Thread.currentThread().getName();
            System.out.println(winner + "获胜");
            return true;
        }

        return false;
    }

    public static void main(String[] args) {
        Demo05 demo05 = new Demo05();
        new Thread(demo05,"兔子").start();
        new Thread(demo05,"乌龟").start();
    }
}

静态代理模式

package bgy210310;

/*
    1.真实对象和代理对象都要实现同一个接口
    2.代理对象要代理真实角色
    
    优点：
    	1.代理对象可以做很多真实对象做不了的事情
    	2.真实对象专注做自己的事情
 */

interface Wedding{
    void happyWedding();
}

// 真实角色，，，谁要结婚
class You implements Wedding{
    @Override
    public void happyWedding() {
        System.out.println("白光一要结婚了，很高心");
    }
}

// 代理角色，，，表示婚庆公司，来个你安排婚礼，帮助你结婚
class WeddingCompany implements Wedding{

    // 真实角色
    private Wedding target;

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

    @Override
    public void happyWedding() {
        before();
        this.target.happyWedding();     // 真实角色
        after();
    }

    private void after() {
        System.out.println("结婚之后，婚庆公司拿钱，撤散现场");
    }

    private void before() {
        System.out.println("结婚之前，婚庆公司策划婚礼，布置现场");
    }

}

public class Demo06 {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.happyWedding();
    }
}

private void after() {
    System.out.println("结婚之后，婚庆公司拿钱，撤散现场");
}

private void before() {
    System.out.println("结婚之前，婚庆公司策划婚礼，布置现场");
}

}

public class Demo06 {
public static void main(String[] args) {
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.happyWedding();
}
}
白光一
关注
专栏目录
JavaSE---日志
白豆五的博客
09-05 415
JavaSE-日志
JavaSE-多线程（4）- CAS
sql2008help的博客
11-13 723
JavaSE-多线程（4）- CAS CAS （CompareAndSwap）举例 例1：在此例中，有 THREAD_COUNT （20）个数量的线程调用 AtomicTest 对象m方法，对属性count进行自增操作，最后在主线程打印count的最终结果为20，由于存在多线程多并发访问count，所以在自增操作前使用synchronized关键字对AtomicTest对象进行了锁定。 package com.hs.example.base.multithread.day01; public class
JavaSE-多线程（11）- LockSupport
sql2008help的博客
11-21 529
JavaSE-多线程（11）- LockSupport 使用LockSupport 类可使线程暂停，请看下例： 例1 线程 t1 执行 LockSupportTest 类run方法，在run方法中，每隔1秒输出一次 i 的值，一共输出10次，在i等于5时暂停线程，主线程睡眠8秒后，调用 activate 方法（实际调用 LockSupportTest 对象即锁的notify方法），t1线程继续执行 package com.hs.example.base.multithread.day01; public
JavaSE-多线程（9）- Semaphore
sql2008help的博客
11-20 485
JavaSE-多线程（9）- Semaphore 解释semaphore前先看下以下例子： 例1 有10个线程同时执行SemaphoreTest任务，从执行结果可以看出，10个线程是同时执行的，等待一段时间后结束。 package com.hs.example.base.multithread.day01; public class SemaphoreTest implements Runnable { @Override public void run() { try
JavaSE-进阶-学习笔记-JUC
qq_52668773的博客
04-03 2103
​ 管程 (英语：Monitors，也称为监视器) 是一种程序结构，结构内的多个子程序（对象或模块）形成的多个工作线程互斥访问共享资源。​ 这些共享资源一般是硬件设备或一群变量。对共享变量能够进行的所有操作集中在一个模块中。（把信号量及其操作原语“封装”在一个对象内部）管程实现了在一个时间点，最多只有一个线程在执行管程的某个子程序。管程提供了一种机制，管程可以看做一个软件模块，它是将共享的变量和对于这些共享变量的操作封装起来，形成一个具有一定接口的功能模块，进程可以调用管程来实现进程级别的并发控制。
JavaSE-多线程基础-基于多线程的计时器应用
wexin_mylove的博客
03-28 1883
JavaSE的多线程的创建以及对于多线程安全的保护，多线程通信以及对于多线程的应用
JavaSE--线程1
ggyggy10的博客
12-08 6262
JavaSE--线程一、线程的概念二、使用步骤1.引入库2.读入数据总结新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习
javaSE--多线程2
ggyggy10的博客
12-09 5867
文章目录一、线程的上下文切换1.线程切换存在的问题二、线程安全(同步)问题三、解决线程安全问题--上锁上锁的方法：1.同步方法2.同步代码块3.同步锁synchronize的基本原理锁对象乐观锁和悲观锁乐观锁总结 一、线程的上下文切换 一个CPU内核中同一时间只能运行一个线程或者一行指令，切换到另一个线程的过程称为线程的上下文切换 1.线程切换存在的问题 1.线程切换的时候如何找到上次执行的地方？ 每个线程中都有各自的程序计数器，用于记录上次执行的行数 线程在上下切换时会消耗时间，性能会降低 二、线
JavaSE-多线程(实现线程安全的三种方式)
weixin_43958460的博客
09-09 753
多线程的线程安全问题 案例：如何使用多线程实现卖票问题？ 给出100张票，让3个线程一起买票，且保证票的唯一性和合法性 实现方式一：使用同步代码块 public class RunnableImpl implements Runnable{ //定义一个多个线程共享的票源 private int ticket = 100; //创建一个锁对象 Object ob...
javaSE-多线程
Antg的博客
07-07 709
文章目录一.基本概念1.程序,进程,线程2.单核和多核CPU3.并行与并发二.线程的创建方法1.方式一:继承Thread类2.实现Runnable接口3.继承Thread和实现Runnable接口的区别三.多线程的使用1.线程的调度2.线程的优先级3.线程的生命周期4.线程控制5.线程的同步概念三.线程同步1.同步方法2.同步锁机制3.释放锁4.Lock(锁)5.使用线程同步解决上面的售票问题5.1使用synchroinzed代码块5.2使用Lock锁 一.基本概念 1.程序,进程,线程 程序:就是一段静
面试-Java一些常见面试题+题解之JavaSE-JavaSE.zip
03-03
- **线程的创建方式**：实现Runnable接口和继承Thread类。 - **线程同步**：synchronized关键字、wait/notify机制、Lock接口。 - **线程池**：ExecutorService、ThreadPoolExecutor的使用与配置。 以上仅是...
javase-思维导图.zip
08-04
Java提供了Thread类和Runnable接口来创建和管理线程，同时还有synchronized关键字、wait()、notify()等同步机制，以及并发工具类如Semaphore、CyclicBarrier等，用于在多线程环境下保证数据的一致性。 最后，Java ...
java8源码-JavaSE-Code:JavaSE的代码练习与学习笔记总结
06-04
interrupted是Thread类的静态方法,里面调用了isTnterrupted方法[currentThread().isInterrupted()],测试当前线程是否已经中断,线程的中断状态由该方法清除 isInterrupted是Thread类的实例方法,不清除中断标志 yield...
面试题总结---javaSE--适用于初学者
07-15
本文将深入解析“面试题总结---javaSE--适用于初学者”这一主题，旨在为初学者提供宝贵的复习资料。 1. **Java基础** - **数据类型**：Java分为基本数据类型（如int、char、boolean等）和引用数据类型（类、接口、...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 69
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 464
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 200
BI商业智能：数据可视化、报表可视化系统。
JDK17新增语法特性
2201_76124988的博客
09-20 807
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 585
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JavaSE中的Thread类详解：启动、命名与优先级设置
"这篇文档主要介绍了Java SE中的Thread类及其常用方法，同时也简述了Java语言的历史、特性以及Java程序的两种主要类型：Applet和Application。Java的平台无关性是其重要特性之一，得益于Java虚拟机（JVM）的支持，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值