java多线程--11

【Java 11】多线程 - 程序、进程、线程、线程的创建和使用、线程的生命周期、线程的同步、线程的通信、JDK5.0新增线程创建方式 一 Idea 1 快捷补全 new Method() 使用Alt + Enter 可补全 Method method = new Method(); psvm : 可生成 main 方法 sout : System.out.println() 快捷输出 soutp=System.out.println("方法形参名 = " + 形参名); soutv=System.out.println("变量名 = " + 变量); soutm=System.out.println(“当前类名.当前方法” 阅读详情

多线程

进程:是一个正在执行的程序
每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元

线程:就是进程中的一个独立的控制单元
线程在控制着进程的执行

一个进程中至少有一个线程

如何自定义线程?
通过对API的查找,java已经提供了对线程这类事物的描述。就是Thread类

创建线程的第一种方式就是继承Thread类
1,定义类继承Thread
目的:将自定义的代码存储在run方法,让线程运行
2,复写Thread中的run方法
3,调用线程的start方法,
该方法有两个作用,启动线程,调用run方法

class Demo extends Thread
{
    public void run()
    {
        for(int x = 0;x<60;x++)
            System.out.println("Demo run---"+x);
    }
}



class ThreadDemo
{
    public static void main(String[] args)
    {

        Demo d = new Demo();//创建好一个线程
        d.start();          //开启线程,并执行该线程的run方法
        //d.run();            //仅仅是对象调用方法,而线程创建了没有运行

        for(int x = 0;x<60;x++)
            System.out.println("hello world----"+x);
    }
}

这里写图片描述

发现运行结果每一次都不同,
因为多个线程都获取CPU的执行权,CPU执行到谁,谁就运行。
明确一点:在某一刻,只能有一个程序在运行。(多核除外)
CPU在做着快速的切换,以达到看上去是同时执行的效果。
我们形象的看成多线程的运行在抢夺CPU的执行权

这就是多线程的一个特性,随机性。谁抢到就执行谁,至于执行多长,CPU说了算。

为什么要覆盖run方法呢

Thread类用于描述线程
该类就定义了一个功能用于存储线程要运行的代码。
该存储功能就是run方法

也就是说Thread类中的run方法,用于存储线程要运行的代码

练习
创建两个线程,和主线程交替运行

原来线程都有自己默认的名称
Thread-编号 该编号从0开始

static Thread currentThread();获取当前线程对象
getName() 获取线程名称

设置线程名称:setName或者构造函数

class Test extends Thread
{
    Test(String name)
    {
        super(name);
    }
    public void run()
    {
        for(int x=0;x<60;x++)
        {
            //System.out.println(Thread.currentThread().getName()+"run..."+x);
            System.out.println(this.getName()+"run..."+x);
        }
    }
}

class ThreadTest
{
    public static void main(String[] args)
    {
        Test t1 = new Test("one");
        Test t2 = new Test("two");
        t1.start();
        t2.start();

        for(int x=0;x<60;x++)
        {
            System.out.println("main run----"+x);
        }
    }
}

需求:简单的卖票程序
多个窗口同时卖票

创建多线程的第二种方式:实现Runnable接口

步骤:
1,定义类实现Runnable接口
2,覆盖Runnable接口中的run方法
将线程要运行的代码存放在该run方法中

3,通过Thread类建立线程对象
4,将Runnable接口中的子类对象作为实际参数传递给Thread类的构造函数
为什么要将Runnable接口的子类对象作为实际参数传递给Thread的构造函数
因为,自定义的run方法所属的对象是Runnable接口的子类对象
所以要让线程去指定对象的run方法,就必须明确该run方法所属的对象
5,调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

class Ticket implements Runnable
{
    private int tick = 100;
    public void run()
    {

        while(true)
        {
            if(tick>0)
            {
                System.out.println(Thread.currentThread().getName()+"...sale:"+tick--);

            }
        }
    }

}
class TicketDemo
{
    public static void main(String[] args)
    {

        Ticket t = new Ticket();

        Thread t1 = new Thread(t);//创建了一个线程
        Thread t2 = new Thread(t);//创建了一个线程
        Thread t3 = new Thread(t);//创建了一个线程
        Thread t4 = new Thread(t);//创建了一个线程

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

实现方式和继承方式有什么区别?

实现方式好处:避免了单继承的局限性
在定义线程时,建立使用实现方式

两种方式区别:
继承Thread:线程代码存放在Thread子类run方法中
实现Runnable,线程存放在接口的子类的run方法中

class Ticket implements Runnable
{
    private int tick = 100;
    public void run()
    {

        while(true)
        {
            if(tick>0)
            {

                try{Thread.sleep(10);}catch(Exception e){}
    System.out.println(Thread.currentThread().getName()+"...sale:"+tick--);
            }
        }
    }
}

class TicketDemo2
{
    public static void main(String[] args)
    {


        Ticket t = new Ticket();

        Thread t1 = new Thread(t);//创建了一个线程
        Thread t2 = new Thread(t);//创建了一个线程
        Thread t3 = new Thread(t);//创建了一个线程
        Thread t4 = new Thread(t);//创建了一个线程

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

这里写图片描述

通过分析,发现打印出了错票(0,-1,-2)

多线程的运行出现了安全问题

问题原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分
还没有执行完,另一条线程参与进来执行,导致共享数据的错误。

解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行

java对于多线程的安全问题提供了专业的解决方式
就是同步代码块

synchronized(对象)
{
需要被同步的代码
}

对象如同锁,持有锁的线程可以在同步中执行
没有持有锁的线程即使获得CPU的执行权,也进不去,因为没有获取锁

同步的前提:
1,必须要有两个或以上的线程
2,必须是多个线程使用同一个锁

必须保证同步中只能有一个线程在运行

好处:解决了多线程的安全问题

弊端:多个线程需要判断锁,较为消耗资源。

class Ticket implements Runnable
{
    private int tick = 100;
    Object obj  = new Object();//synchornized需要对象
    public void run()
    {

        while(true)
        {
            synchronized(obj)
            {


                if(tick>0)
                {

                    //try{Thread.sleep(10);}catch(Exception e){}

                    System.out.println(Thread.currentThread().getName()+"...sale:"+tick--);
                }
            }
        }
    }

}
class TicketDemo2
{
    public static void main(String[] args)
    {


        Ticket t = new Ticket();

        Thread t1 = new Thread(t);//创建了一个线程
        Thread t2 = new Thread(t);//创建了一个线程
        Thread t3 = new Thread(t);//创建了一个线程
        Thread t4 = new Thread(t);//创建了一个线程

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

需求:
银行有一个金库
有两个储户分别存300,每次存一百,存三次

目的:该程序是否有安全问题,如果有,如何解决

如何找到问题?
1,明确哪些代码是多线程运行代码
2,明确共享数据
3,明确多线程运行代码中哪些语句是操作共享数据的

class Bank
{
    private int sum;
    //Object obj = new Object();
    public synchronized void add(int n)//有了同步函数
    {
        //synchronized(obj)//不需要同步代码块
        //{
            sum = sum+n;
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println("sum="+sum);
        //}
    }
}

class Cus implements Runnable
{
    private Bank b = new Bank();
    public void run()
    {
        for(int x=0;x<3;x++)
        {
            b.add(100);
        }
    }
}

class BankDemo
{
    public static void main(String[] args)
    {
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}

同步函数用的是哪一个锁?
函数需要被对象调用,那么函数都有一个所属对象引用。就是this
所以同步函数使用的锁是this

通过该程序进行验证

使用两个线程来卖票
一个线程在同步代码块中
一个线程在同步函数中
都在执行卖票动作

class Ticket implements Runnable
{
    private int tick = 100;
    Object obj  = new Object();
    boolean flag = true;
    public void run()
    {
        if(flag)
        {
            while(true)
            {
                synchronized(this)
                {
                    if(tick>0)
                    {

                        try{Thread.sleep(10);}catch(Exception e){}

                        System.out.println(Thread.currentThread().getName()+"...code:"+tick--);
                    }

                }
            }
        }
        else
            while(true)
                show();

    }
    public synchronized void show()//this
    {
        if(tick>0)
            {

                try{Thread.sleep(10);}catch(Exception e){}

                System.out.println(Thread.currentThread().getName()+"...show....:"+tick--);
            }
    }
}
class ThisLockDemo
{
    public static void main(String[] args)
    {


        Ticket t = new Ticket();

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

        t1.start();
        try{Thread.sleep(10);}catch(Exception e){}
        t.flag = false;
        t2.start();
    }
}

这里写图片描述

如果同步函数被静态修饰后,使用的锁是什么?

通过验证,发现不再是this。因为静态方法中也不可以定义this

静态进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象
类名.class 该对象的类型是class

静态的同步方法,使用的那个锁是该方法所在类的字节码文件对象。类名.class

class Ticket implements Runnable
{
    private static int tick = 100;
    boolean flag = true;
    public void run()
    {
        if(flag)
        {
            while(true)
            {


                synchronized(Ticket.class)
                {
                    if(tick>0)
                    {

                        try{Thread.sleep(10);}catch(Exception e){}

                        System.out.println(Thread.currentThread().getName()+"...code:"+tick--);
                    }

                }
            }
        }
        else
            while(true)
                show();

    }
    public static synchronized void show()//this
    {
        if(tick>0)
            {

                try{Thread.sleep(10);}catch(Exception e){}

                System.out.println(Thread.currentThread().getName()+"...show....:"+tick--);
            }
    }


}
class StaticMethodDemo
{
    public static void main(String[] args)
    {

        Ticket t = new Ticket();

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


        t1.start();
        try{Thread.sleep(10);}catch(Exception e){}
        t.flag = false;
        t2.start();

    }
}

单例设计模式

饿汉式

class Single
{
    private static final Single s = new Single();
    //加了一个final
    private Single(){}
    public static Single getInstance()
    {
        return s;
    }

class SingleDemo
{
    public static void main(String[] args)
    {

    }
}

懒汉式

class Single
{
    private static Single s = null;
    private Single(){}


    public static  Single getInstance()
    {
        if(s==null)//减少锁的判断的次数
        {
            synchronized(Single.class)
            {
                if(s==null)
                    s = new Single();
            }
        }
        return s;
    }
}


class SingleDemo
{
    public static void main(String[] args)
    {

    }
}

死锁

死锁
同步中嵌套同步

class Ticket implements Runnable
{
    private int tick = 100;
    Object obj  = new Object();
    boolean flag = true;
    public void run()
    {
        if(flag)
        {
            while(true)
            {

                synchronized(obj)
                {
                        show();
                }
            }
        }
        else
            while(true)
                show();

    }
    public synchronized void show()//this
    {
        synchronized(obj)
        {
            if(tick>0)
            {

                try{Thread.sleep(10);}catch(Exception e){}

                System.out.println(Thread.currentThread().getName()+"...code:"+tick--);
            }
        }
    }   
}
class DeadLockDemo
{
    public static void main(String[] args)
    {


        Ticket t = new Ticket();

        Thread t1 = new Thread(t);//创建了一个线程
        Thread t2 = new Thread(t);//创建了一个线程


        t1.start();
        try{Thread.sleep(10);}catch(Exception e){}
        t.flag = false;
        t2.start();

    }
}

这里写图片描述

实际开发中要避免死锁。

(1)大蚂蚁即时通讯 即时通讯软件BigAnt(大蚂蚁)是杭州艾朴软件推出的一个”企业级”的即时通讯平台。该平台专为企业,其他企事业单位和政府单位而设计,目的就是为了增强内部沟通能力,提高内部员工的工作效率;同时服务器就直接置于单位内部,所有信息由单位自己管理,让单位以更安全、更可伸缩和更易于管理的方式灵活方便地使用协同和通信服务的功能! BigAnt(大蚂蚁)即时通讯软件包括服务器端和客户端。客户端功能包括单位 阅读详情

相关推荐

CentOS7.9 安装 ImageMagick,图片转换为HEIC图像格式

由于ImageMagick7以下不支持heic等图片格式,所以重新安装了ImageMagick7.1版本支持heic格式,在网上找了很多资料,归纳总结并写此文章记录一下。在Linux(CentOS7.9)上安装ImageMagick7.1.1-38。

shmily_i的博客 1942

java语言的多线程特征解释_JAVA语言的11个特性

java语言的11个特性:java语言是一种简单的(Simple),面向对象的(Object-Oriented),分布式的(Distributed),解释性的(interpreted),健壮的(Robust),安全的(Secure),结构中立的(Architecture-neutral),可移植的(Portable),高性能的(high-performace),多线程的(multi-threade...

weixin_39732249的博客 548

从零构建HFSS连接器仿真模型:以SMP接口的精准复现为例

本文详细介绍了如何从零构建HFSS连接器仿真模型,以SMP接口的精准复现为例。通过获取官方模型、导入技巧、信号路径提取和介质结构复现等步骤,帮助工程师避免常见错误,提升高频电路仿真的准确性。文章特别强调了模型精度对仿真结果的影响,并提供了实用的调试和管理建议。

weixin_29041767的博客 433

JAVA高级进阶11多线程

线程安全问题多线程给我们带来了很大性能上的提升,但是也可能引发线程安全问题线程安全问题指的是当个多线程同时操作同一个共享资源的时候,可能会出现的操作结果不符预期问题。

2402_84667776的博客 1353

从零到一:用ROS2和Gazebo搭建Franka机械臂仿真环境(避坑指南)

本文详细介绍了如何使用ROS2和Gazebo从零开始搭建Franka机械臂的仿真环境,包括环境准备、ROS2包安装、控制器配置及常见问题解决方案。特别针对关节位置控制等核心功能提供了实用代码示例和避坑指南,帮助开发者高效构建机器人算法验证平台。

weixin_29061465的博客 465

【OAG vs RAG】RAG的“语义崩溃“:为什么你的知识库越大,AI越笨?_语义检索oag-优快云博客

19.9 元(AI 编程 / Agent 实战 | 本文同主题系统课程)·49.9 元(AI 时代成长方法论)。单篇不过瘾?订阅解锁全量源码、实战与答疑;文末附资料包领取方式 ↓图1:RAG语义崩溃概念图。

求知若渴、虚心若愚 73

Java学习(11)——多线程

多线程简介什么是线程多线程实现线程变量线程同步死锁饥饿线程生命周期 简介 Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。多线程是多任务的一种特别的形式,但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。本节主要讲解 Java 多线程的一些概念以及其实现。 知识...

B_Sheep的博客 631

[QMT量化交易小白入门]-七十三、主力资金动向:板块与个股资金流数据API(量化python代码解析)

本专栏主要是介绍QMT的基础用法,常见函数,写策略的方法,也会分享一些量化交易的思路,大概会写100篇左右。QMT的相关资料较少,在使用过程中不断的摸索,遇到了一些问题,记录下来和大家一起沟通,共同进步。

木头大左的博客 1122

Java基础_11 多线程

多线程 进程 正在运行的程序 线程 是操作系统能够进行运算调度的最小单位 Thread类(线程类) 构造 public Thread(); //创建一个无名线程对象 public Thread(String name); //创建一个指定名字的线程对象 创建新线程的方法 方法一: 定义子类继承Thread类 在子类中重写run方法 创建子类对象 开启这...

SleepNot_Need的博客 221

DeepSeek 赋能招投标全流程智能化:多模态解析、知识图谱与投标文件自动生成实战指南(附完整代码与行业案例)

摘要:本文深入探讨DeepSeek技术在招投标领域的全流程智能化应用,通过整合自然语言处理(NLP)、多模态解析、知识图谱等核心技术,实现招标文件智能解析与投标文件自动生成。文中详细解析DeepSeek-R1模型的多模态处理机制、动态知识图谱构建方法及智能模板填充算法,通过完整代码实现展示技术细节。结合广某资源交易平台、山西XX"XX云"等典型案例,验证技术方案在提升招投标效率、降低人为错误方面的显著效果。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1464

基于STM32单片机设计的智能坐垫_431

本文设计了一款基于STM32F103C8T6单片机的智能坐垫系统,该系统集成了压力传感器、SHT30温湿度传感器、薄膜加热垫、涡轮风机、语音播报模块、OLED显示屏及HC-05蓝牙模块,实现了对用户就坐状态与坐垫微环境的实时监测与智能调控。系统通过压力传感器检测用户就坐情况,自动启动久坐计时并触发语音提醒;温湿度数据用于控制通风与加热功能,以改善座椅舒适性;用户可通过按键或手机APP设置久坐时长、手动开关通风与加热,并通过OLED屏或APP实时查看环境参数与计时状态。本设计体现了嵌入式系统在健康关怀与舒适性

410

java初学笔记11-多线程

线程程序、进程、线程的概念Java中多线程的创建和使用线程的生命周期线程的同步线程的通信 程序、进程、线程的概念 **程序(program)**是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码, 静态对象。 **进程(process)**是 Java中多线程的创建和使用 继承Thread类与实现Runnable接口 Thread类的主要方法 线程的调度与设置优先级 线程的生命周期 线程的同步 线程的通信 ...

chenyao的博客~ 285

CEEMDAN算法及其应用

本博文主要介绍CEEMDAN算法的原理及其在信号去噪方面的应用

总结论文中的算法并给出论文的复现代码 6万+

小白学习java第11天(上):多线程详解

这就是我上面绘制的那个图片,我是单独开启的一个线程,而不是像原来那样对其进行调用run方法,调用run方法可能就是先执行(0-19)然后再执行(0-1999)这样就是我们普通的程序,但是想我上面进行多线程,就是进行交叉执行的,而这么进行选择就是CPU所控制的!下面对这两种方法进行简单的不同说明(需要知道后面的静态代理什么意思!【我比较推荐第二个,接口的好处就是避免了单继承的局限,灵活方便,方便对同一个对象被多个线程使用,一个对象创建多个线程(一个对象多个代理)

ambition__king的博客 293

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Java笔记-11 多线程

文章目录多线程Thread 多线程 进程是资源分配的单位,线程是调度和执行的单位。 多线程的三种方式,继承Thread类,实现Runnable接口,实现Callable接口,前两种常用,第二个更常用,因为无法多继承,可以实现多个接口 继承Thread类,重写run方法,构建对调用start方法 实现Runnable接口,重写run方法,通过new Thread(对象).start()调用 Th...

自度度人 自觉觉他 435

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Java PTA(11)——多线程

yield(): yield是 Thread 类中的方法,能够暂停当前正在执行的线程对象,不会释放资源锁,也被称为礼让线程,和 sleep 不同的是 yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,使用该方法后,需要与其它线程再次重新争夺CPU,谁抢到谁执行。在synchronized代码被执行期间,线程调用对象的wait()方法,会释放对象锁标志,然后进入等待状态,然后由其它线程调用notify()或者notifyAll()方法通知正在等待的线程。//(标志)是否有产品在缓冲。

m0_61442114的博客 1703

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Java高级:从多线程到java11新特性

参考:尚硅谷 Java基础 8.多线程 9.Java常用类 10.枚举类和注解 11.Java集合 12.泛型 13.IO流 14.网络编程 15.Java反射机制 16.Java8其他新特性 17.Java9/10/11新特性

qq_43349162的博客 552

回归java11-java进阶-多线程编程

文章目录多线程编程基础知识进程线程主线程创建子线程实现Runnable接口继承Thread线程类使用匿名内部类和Lambda表达式实现线程体线程状态线程管理线程优先级等待线程结束线程让步线程停止线程安全临界资源问题多线程同步synchronized方法synchronized语句线程间通信 多线程编程 基础知识 进程 一般可以在同一时间内执行多个程序的操作系统都有进程的概念。 一个进程就是一个执行...

yilin^_^的博客 415

11-Java多线程基础

Java 多线程基础 1. 相关概念 程序、进程、线程 程序:为了让计算机完成特定功能的一系列有序指令的集合。 进程:是系统进行资源分配和调度的基本单位,简单理解为,正在运行的程序。有自己的生命周期,如:正在运行的QQ,微信,word等。 线程:CPU的调度单位,进程中的一个实体,资源的拥有者还是进程。一个进程包含1—n个线程。 为什么要引进进程? 进程的引入是为了使多个程序并发执行以改善系统资源的利用率和系统的吞吐量。 有了进程为什么还要引入线程呢? 虽然进程能够改善系统资源的利用率和系统的吞吐量。

Kunaly 1249

11.1Java多线程基础篇

进程:我们把一个任务称为一个进程。例如:浏览器、视频播放器、word等都是进程。 线程:进程中分很多子任务,这些子任务就是线程。例如:word打字过程中,进行着拼写检查。 进程线程关系:进程可以包含多个线程,但至少有一个线程。 实现多任务的方式: 多进程模式(每个进程只有一个线程) 多线程模式(一个进程有多个线程) 多进程+多线程模式(复杂度最高) 在具体实现时,要考虑到进程和线程的特点。 多进程的缺点: 创建进程开销更大。 进程间通信比线程慢,线程间通信是读写同一个变量。 多进程的优点:稳定性高,

No_senior_freshman的博客 158

java多线程系列11-多线程下HashMap源码分析

1.Hashmap hashmap低层数据结构用的是数组加链表。这时候就会涉及到几个问题,如何定位数据在hashmap中的位置?如何减少hash冲突?如何保证hash值不超过数组的长度。 1.1 hash 哈希:把任意长度的输入通过一种算法(散列),变换成为固定长度的输出,这个输出值就是散列值。属于压缩映射,容易产生哈希冲突。 产生哈希冲突时解决办法:1.开放寻址;2、再散列;3、链地址法(相同h...

哼哼的博客 210

Java学习11(多线程)

/**使用Thread类实现线程*/ public class ThreadTest extends Thread{ //指定类继承Thread类 private int count = 10; public void run(){ while(true){ System.out.print(count+" "); //打印count变量 if(--count == 0){ Syste...

mjl_man的博客 223

11 java里的多线程

方法1: 通过扩展类Thread来实现, 如自定义一个MyThread线程类 class MyThread extends Thread { public void run() { //在此函数里写线程要执行的代码 } } //使用: new MyThread().start; //注意run函数成员不是直接调用的如实

jklinux的博客 571

java11多线程

1. 本周学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总结多线程相关内容。 2. 书面作业 本次PTA作业题集多线程 1. 源代码阅读:多线程程序BounceThread 1.1 BallRunnable类有什么用?为什么代码中需要调用Thread.sleep进行休眠? 在BallRunnable类中有Runnable接口,可实现多线程。 调用了sleep,可以延缓线程完成的时间。...

weixin_30348519的博客 115

Java学习笔记11-多线程工具类实战

Java学习笔记11-多线程工具类实战 Runnable接口 Runnable是个接口,里面只有个run方法,Thread也实现Runnable接口,所以要实现多线程那你最终要实现Runnable接口,不多说直接上代码演示。 Runnable测试代码 public class RunnableDemo { public static void main(String[] args) { ...

Wenx 247

黑马程序员_JAVA笔记11——多线程

------- android培训、java培训、期待与您交流! ---------- 1、多线程     进程:是一个正在执行的程序。每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元。     线程:就是进程中的一个独立的控制单元,线程在控制着进程的执行。     一个进程中至少有一个线程。     java VM  启动的时候会有一个进程 ja

u011453546的专栏 658
上一篇: java异常,包--10
下一篇: java多线程--12
飞鸿踏雪泥-
博客等级 码龄12年 4粉丝 48原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值