java多线程--12

KBS投稿全流程拆解:从模板准备到条件接收的实战指南 本文详细拆解了KBS期刊投稿的全流程,从模板准备、投稿系统操作到返修策略和条件接收。重点介绍了Cover Letter撰写技巧、Latex模板选择、审稿周期管理以及返修文件的系统准备方法,帮助研究者高效完成KBS投稿并提升接收概率。 阅读详情

线程间通讯

其实就是多个线程在操作同一个资源,但是操作的动作不同

notifyAll();

wait:
notify();
notifyAll();

都使用在同步中,因为要对持有监视器(锁)的线程操作
所以要使用在同步中,因为只有同步才具有锁

为什么这些操作线程的方法要定义object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作线程持有的锁。
只有同一个锁上的被等待线程,可以被同一个锁上notify唤醒
不可以对不同锁中的线程进行唤醒。

也就是说,等待和唤醒必须是同一个锁
而锁可以是任意对象,所以可以被任意对象调用的方法定义Object类中

class Res
{
    String name;
    String sex;
    boolean flag = false;


}

class Input implements Runnable
{
    private Res r;

    Input(Res r)
    { 
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            synchronized(r)
            {
                if(r.flag)
                    try{r.wait();}catch(Exception e){}
                if(x==0)
                {
                    r.name = "mike";
                    r.sex = "man";
                }
                else
                {
                    r.name = "丽丽";
                    r.sex = "女女女女";
                }

            x = (x+1)%2;
            r.flag = true;
            r.notify();
            }
        }
    }
}

class Output implements Runnable
{
    private Res r;

    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            synchronized(r)
            {
                if(!r.flag)
                    try{r.wait();}catch(Exception e){}
                System.out.println(r.name+"....."+r.sex);
                r.flag = false;
                r.notify();
            }
        }
    }
}

class InputOutputDemo
{
    public static void main(String[] args)
    {
        Res r = new Res();

        Input in = new Input(r);
        Output out = new Output(r);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);

        t1.start();
        t2.start();
    }
}

这里写图片描述

简化版

class Res
{
    private String name;
    private String sex;
    private boolean flag = false;

    public synchronized void set(String name,String sex)
    {
        if(flag)
            try{this.wait();}catch(Exception e){}

        this.name = name;
        this.sex = sex;

        flag = true;
        this.notify();
    }
    public synchronized void out()
    {
        if(!flag)
            try{this.wait();}catch(Exception e){}
        System.out.println(name+"..."+sex);
        flag = false;
        this.notify();
    }
}
class Input implements Runnable
{
    private Res r;
    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            if(x==0)
                r.set("mike","man");
            else
                r.set("丽丽","女女女");
            x = (x+1)%2;
        }
    }
}

class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}
class InputOutputDemo2
{
    public static void main(String[] args)
    {
        Res r = new Res();

        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();

    }
}

这里写图片描述

生产者与消费者案例

class ProducerConsumerDemo
{
    public static void main(String[] args)
    {
        Resource r = new Resource();

        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;


    public synchronized void set(String name)
    {
        while(flag)
            try{this.wait();}catch(Exception e){}
        this.name = name+"--"+count++;
        System.out.println(Thread.currentThread().getName()+"...生产者......"+this.name);
        flag = true;
        this.notifyAll();
    }
    public synchronized void out()
    {
        while(!flag)
            try{wait();}catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name);
        flag = false;
        this.notifyAll();
    }
}
class Producer implements Runnable
{
    private Resource res;

    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            res.set("+商品+");
        }
    }
}
class Consumer implements Runnable
{
    private Resource res;

    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            res.out();
        }
    }
}

这里写图片描述

对于多个生产者和消费者
为什么要定义while判断标记
原因:让被唤醒的线程再一次判断标记

为什么定义notifyAll
因为需要唤醒对方线程
因为只用notify,容易出现只唤醒本方线程的情况,导致程序中所有的线程都等待

Lock替代Synchronized

import java.util.concurrent.locks.*;

class ProducerConsumerDemo2
{
    public static void main(String[] args)
    {
        Resource r = new Resource();

        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;

    private Lock lock = new ReentrantLock();

    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();

    public  void set(String name) throws InterruptedException
    {
        lock.lock();
        try
        {
            while(flag)
                condition_pro.await();
            this.name = name+"--"+count++;
            System.out.println(Thread.currentThread().getName()+"...生产者........."+this.name);
            flag = true;
            condition_con.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
    public void out() throws InterruptedException
    {
        lock.lock();
        try
        {
            while(!flag)
                condition_con.await();
            System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name);
            flag = false;
            condition_pro.signal();
        }
        finally
        {
            lock.unlock();  //释放锁的动作一定要执行
        }
    }
}
class Producer implements Runnable
{
    private Resource res;

    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.set("+商品+");
            }
            catch(InterruptedException e)
            {

            }

        }
    }
}
class Consumer implements Runnable
{
    private Resource res;

    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.out();
            }
            catch(InterruptedException e)
            {

            }
        }
    }
}

这里写图片描述

JDK1.5 中提供了多线程升级解决方法
将同步Synchronized替换成现实Lock操作
将Object中的wait,notify notifyAll,替换成了Condition对象
该对象可以Lock锁 进行获取
该实例中,,实现了本方只唤醒对方的操作

停止线程

如何停止线程?
只有一种,run方法结束
开启多线程运行,运行代码通常是循环结构

只要控制住循环,就可以让run方法结束,也就是线程结束

class StopThread implements Runnable
{
    private boolean flag = true;
    public void run()
    {
        while(flag )
        {
            System. out.println(Thread.currentThread().getName() + "...run");
        }
    }
    public void changeFlag()
    {
        flag = false ;
    }
}

class StopThreadDemo
{
    public static void main(String[] args)
    {
        StopThread st = new StopThread();

        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);

        t1.start();
        t2.start();

        int num = 0;
        while(true)
        {
            if(num++ == 60)
            {
                st.changeFlag();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"....."+num);
        }   

      }
}

这里写图片描述

stop()已经过时了。不再使用。

特殊情况:
当线程处于了冻结状态,
就不会读取到标记。那么线程就不会结束

当没有指定的方式让冻结的线程恢复到运行状态时:这时需要对冻结进行清除
强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束。
Thread类中提供了该方法:Interrupt()
Interrupt():中断线程,强制让线程恢复到运行状态上来。会发生InterruptedException,一定要记得处理。

class StopThread implements Runnable
{
    private boolean flag = true;
    public synchronized void run()
    {
        while(flag)
        {
            try
            {
                wait();
            }
            catch(InterruptedException e)
            {
                System.out.println(Thread.currentThread().getName()+".....Exception");
                flag = false;
            }
            System.out.println(Thread.currentThread().getName()+".....run");
        }
    }
    public void changeFlag()
    {
        flag = false;
    }
}

class StopThreadDemo
{
    public static void main(String[] args)
    {
        StopThread st = new StopThread();

        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);

        t1.start();
        t2.start();

        int num = 0;

        while(true)
        {
            if(num++ == 60)
            {
                //st.changeFlag();
                t1.interrupt();
                t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"....."+num);
        }   
        System.out.println("over");
    }
}

这里写图片描述

setDaemon 守护线程
当运行的线程都是守护线程时,java虚拟机退出
该方法必须在启动线程前调用。

class StopThread implements Runnable
{
    private boolean flag = true;
    public synchronized void run()
    {
        while(flag)
        {
            try
            {
                wait();
            }
            catch(InterruptedException e)
            {
                System.out.println(Thread.currentThread().getName()+".....Exception");
                flag = false;
            }
            System.out.println(Thread.currentThread().getName()+".....run");
        }
    }
    public void changeFlag()
    {
        flag = false;
    }
}

class StopThreadDemo
{
    public static void main(String[] args)
    {
        StopThread st = new StopThread();

        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);

        t1.setDaemon(true);
        t2.setDaemon(true);
        t1.start();
        t2.start();

        int num = 0;

        while(true)
        {
            if(num++ == 60)
            {
                //st.changeFlag();
                //t1.interrupt();
                //t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"....."+num);
        }   
        System.out.println("over");
    }
}

这里写图片描述

join

join:
当A线程执行到了B线程的.join()方法时,A就会等待,等B线程都执行完,A才会执行

join可以用来临时加入线程执行。

class Demo implements Runnable
{
    public void run()
    {
        for(int x=0;x<70;x++)
        {
            System.out.println(Thread.currentThread().getName()+"....."+x);
        }
    }
}

class JoinDemo
{
    public static void main(String[] args) throws Exception
    {
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);

        t1.start();

        t2.start();
        t1.join();


        for(int x=0;x<80;x++)
        {
            System.out.println("main....."+x);
        }
        System.out.println("over");
    }
}

这里写图片描述

class ThreadTest
{
    public static void main(String[] args)
    {
        //线程1
        new Thread()
        {
            public void run()
            {
                for(int x=0;x<100;x++)
                {
                    System.out.println(Thread.currentThread().getName()+"...."+x);
                }
            }
        }.start();


        //线程2
        for(int x=0;x<100;x++)
        {
            System.out.println(Thread.currentThread().getName()+"....."+x);
        }


        //线程3
        Runnable r  = new Runnable()
        {
            public void run()
            {
                for(int x=0;x<100;x++)
                {
                    System.out.println(Thread.currentThread().getName()+"......"+x);
                }
            }
        };
        new Thread(r).start();

        //new Test1().start();
    }

}
/*
class Test1 extends Thread
{
    public void run()
    {
        for(int x=0;x<100;x++)
        {
            System.out.println(Thread.currentThread().getName()+"...."+x);
        }
    }
}
*/
YOLOv11与Roboflow数据预处理实战:从原始数据到高性能模型 摘要 Roboflow平台与YOLOv11的结合为计算机视觉开发者提供了高效的工作流。Roboflow提供数据集管理、预处理、增强和导出的一站式解决方案,支持多种标注格式并与YOLOv11无缝集成。YOLOv11在YOLO系列基础上进行了架构创新,包括深度宽度优化、C3k2机制和C2PSA注意力机制,提供从纳米版到超大版的多种模型变体。 使用Roboflow的流程包括:注册工作区、收集/导入数据(支持本地和公开数据集)、专业标注(含SAM辅助)、预处理(尺寸调整、归一化等)和数据增强(几何变换和颜色调整)。 阅读详情

相关推荐

Vue3多级路由缓存失效的深度解析与实战解决方案

本文深度解析了Vue3项目中多级路由下keep-alive缓存失效的根本原因,并提供了三种实战解决方案:通过路由扁平化根治问题、利用状态管理精细模拟缓存效果,以及借助keep-alive-vue3插件快速修复。文章旨在帮助开发者彻底理解Vue Router与keep-alive的协作机制,从而根据项目情况选择最佳策略,有效解决页面状态丢失的难题。

weixin_29015801的博客 286

DeepSeek Java 多线程打印的12种实现方法

这些方法涵盖了Java并发编程的主要工具类,你可以根据具体需求选择合适的方法。synchronized 简单易用,JVM内置 性能相对较低 简单的同步需求。ReentrantLock 功能丰富,性能好 需要手动释放锁 复杂的同步需求。Exchanger 线程间数据交换 只能两个线程 配对线程数据交换。Semaphore 灵活的许可控制 可能产生死锁 资源池、限流。Phaser 灵活的阶段控制 相对复杂 多阶段复杂任务。线程池 资源管理 需要关闭线程池 任务执行管理。Java 多线程打印的12种实现方法。

m0_37843156的博客 321

Unity类银河战士恶魔城学习总结(P162 Improve skeleton提升敌人的效果)

为敌人添加了快慢刀

suzh1qian的博客 573

java多线程12种设计模式

1、Single Threaded Execution Pattern(单线程执行模式)

堆码时刻 4265

基于Codex平台与AI Agent技能开发,实现抖音爆款视频分析与脚本自动生成

大家好,我是专注于AI应用开发的技术博主。最近在探索如何利用AI工具自动化内容创作时,我发现了一个非常有趣的组合:通过Codex平台创建自定义的Skill(技能),来批量分析抖音平台的爆款视频,并基于分析结果自动生成新的带货视频脚本。这听起来像是内容团队的“黑科技”,但实现起来其实有清晰的路径可循。本文将为你完整拆解这个实战项目,从环境搭建、Skill编写、数据抓取到视频脚本生成,手把手教你打造自己的“AI内容助理”。无论你是想了解AI Agent的开发,还是对短视频自动化创作感兴趣,都能从本文中获得可直接

weixin_34110749的博客 645

理想汽车智驾方案介绍 4 World model + 强化学习重建自动驾驶交互环境

本帖将以 DrivingSphere 为例来解析这个过程。

地平线开发者 1921

Java进阶12 多线程

线程、进程、开启线程的三种方式、线程安全和同步、线程通信、生产者消费者模式

summer_9823的博客 1237

threekingdoms.txt中文三国演义下载及实现人物出场统计

threekingdoms.txt全文下载:https://python123.io/resources/pye/threekingdoms.txt CalThreeKingdomsV1.py: #CalThreeKingdomsV1.py import jieba txt = open("threekingdoms.txt", "r", encoding = "utf-8").read() words = jieba.lcut(txt) counts = {} for word in words:

ZYYRWish_97的博客 1万+

java多线程12设计模式

1、Single Threaded Execution Pattern(单线程运行模式) 2、Immutable Pattern(一成不变的模式) 3、Guarded Suspension Pattern(国防暂停模式) 4、Balking Pattern(止步模式,阻行模式) 5、Producer-Consumer Pattern(生产者-消费者模式) 6、Read-...

aofan9566的博客 149

ROS2多线程处理RTSP视频流避坑指南:OpenCV解码丢帧问题解决方案

本文针对ROS2中处理RTSP视频流时OpenCV解码丢帧的常见问题,提供了专业的解决方案。通过深入分析单线程模型的瓶颈,提出并详细拆解了基于生产者-消费者多线程模型的健壮实现方案,有效分离数据采集与处理,从而显著提升视频流的稳定性和流畅度。

weixin_29199873的博客 168

如何用Deep OC-SORT提升多目标跟踪精度?实战配置与性能优化指南

本文是一份针对开发者的Deep OC-SORT多目标跟踪实战指南。详细解析了如何通过部署其核心的“动态外观记忆”与“相机防抖”模块来有效应对遮挡与抖动,从而显著提升跟踪精度与连续性。内容涵盖从环境搭建、参数调优到性能压榨的全流程,并提供针对不同场景的配置建议与工程落地技巧。

f9g0h的博客 670

【Java SE】12.Java多线程

本文详细介绍了Java多线程

Nian_kuian的博客 1232

基于 MATLAB 的综合能源系统建模案例 

电平衡约束:P_{gt}(t)+P_{grid}(t)-P_{eb}(t)-P_{load}(t)=0,其中 P_{grid}(t) 为与外部电网的交互功率(正表示购电,负表示售电)。- 电锅炉的热输出功率 Q_{eb} 与输入电功率 P_{eb} 的关系为:Q_{eb}=\eta_{eb}\times P_{eb},其中 \eta_{eb} 为电锅炉的热效率。- 燃气轮机的余热回收功率 Q_{gt} 与发电功率也存在一定关系,例如:Q_{gt}=c\times P_{gt},c 为余热回收比例系数。

qq_57128262的博客 1396

Java多线程学习--12

说明:参考《Java多线程核心技术》 8、Condition类 Condition类:可以实现多路通知功能,也就是在一个Lock对象里面创建多个Condition(即对象监视器)实例,线程对象可以注册在指定的Condition中,从而可以有选择性的进行线程通知,在调度线程上更加灵活。 public class ConditionService { private Lock lock = n...

泡椒酱的的Java学习记录 189

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

12. Java多线程

Java多线程

Buluchacha的博客 919

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Java多线程编程终极指南:12个设计模式实战解析

Java多线程编程是每个开发者必须掌握的核心技能,特别是在当今多核CPU普及的时代。本项目《Java多线程编程实战指南(设计模式篇)》源码提供了完整的Java多线程设计模式实现,帮助开发者轻松应对复杂的并发编程挑战。🚀 ## 📚 项目概述 这个Java多线程编程项目是国内首部专注于多线程设计模式的原创作品,涵盖了从基础概念到高级实战的完整知识体系。通过12个精心设计的多线程模式,开发者可以

gitblog_00025的博客 476

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Java基础 - 12 - 多线程

Java基础 - 12 - 多线程

qq_50755868的博客 905

第12篇-JAVA 多线程

第12篇-JAVA 多线程 每篇一句 :不要只看到艰难,要看艰难后面的胜利 初学心得: 敢于尝试,就等于你已经向成功迈出了第一步 (笔者:JEEP/711)[JAVA笔记 | 时间:2017-04-20| JAVA 多线程 ] 目录导航第12篇-JAVA 多线程 目录导航 进程与线程 继承Thread类创建线程类 实现Runnable接口创建线程类 线程睡眠 两种线程方式的对比 线程生命周期 线程

JEEP/711 Blog 460

【Java基础系列】第12章 多线程

12.1 多线程的基本概念 12.1.1线程与进程 进程:执行中的程序 线程:线程是轻量级的进程,不能单独运行,只能放在一个进程中才能执行 12.1.2 java的线程模型 1.使线程暂停 ①调用sleep( )方法 ②调用wait( )方法 ③等待输入/输出完成 2.使线程进入就绪状态 ①线程调用notify( )方法 ②线程调用notifyAll( )方法 //通知全部线程就绪 ...

Yvan 310

java基础12多线程

/*  * 如何在我们自定义的程序中去创建一个线程(执行路径,控制单元)呢?  * 如何让自定义的线程运行我们执行的代码,可以和主线程同时执行呢?  *   * 如何创建一个线程呢?  * 其实java中对线程这类事物已经进行了描述,并提供了相应的对象,  * 这个对象就是Thread  *   * 通过API查询,发现Thread类描述时,有两种创建线程的方式  * 方式1;定

li1367356的博客 248

Java第12章学习总结(Java多线程机制)

教材学习总结 进程与线程 1  操作系统与进程 进程是程序的一次动态执行过程。现代操作系统可以同时管理计算机系统的多个线程 2  进程与线程 线程不是进程,线程是比进程更小的执行单位,线程的中断与恢复可以更加节省系统的开销。 Java中的线程 Java的多线程机制 Java语言的一大特性点就是内置对多线程的支持,多线程指一个应用程序中同时存在几个执行体,按几条不同的执行线索共同工作...

weixin_41842123的博客 325

java多线程编程(打印12A34B...5152Z)

1.题目描述 写两个线程,一个线程打印1-52,一个线程打印A-Z,打印顺序为12A34B56C...5152Z. 2.解题思路 2.1先写打印数字的方法 // 设置标记位,如果flag为true,打印两个数字;如果flag为false,打印一个字母 private boolean flag = true; // 创建一个变量count用来往后打印 priva...

chainsmoker_的博客 1022

2017.12.12 java多线程

用Thread的子类创建线程 用Runnable接口方式创建线程

Mongo_girl 327

12.Java 多线程编程

本文介绍了Java多线程的基础知识,包括线程的概念、创建线程的三种主要方式(继承Thread类、实现Runnable接口、实现Callable接口),以及线程池的使用。文章还详细讲解了线程的基本信息与控制方法,如线程优先级、状态切换(sleep、yield、join等),以及多线程的优缺点。通过源码分析和实践案例,帮助读者全面理解多线程编程的核心概念和应用场景。

yang_xs的博客(只讲干货) 491
上一篇: java多线程--11
下一篇: java String功能--13
飞鸿踏雪泥-
博客等级 码龄12年 4粉丝 48原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值