多线程的描述

最新推荐文章于 2022-03-27 17:06:45 发布
最新推荐文章于 2022-03-27 17:06:45 发布
阅读量153 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Abaiyu321/article/details/119008502
版权

线程的状态：
        新生状态：new Thread(),当前线程处于新生状态
        就绪状态;start()，这个线程进入到就绪状态，线程准备好可以被cpu调度
        运行状态：当cpu调度到这个线程,线程进入到运行状态开始执行
        阻塞状态 : 当程序无法正常执行(进入阻塞状态的多种方式...)
         终止状态 : 线程结束
注意：
        1.一个线程一旦终止,无法恢复
        2.一个线程如果进入阻塞状态,阻塞接触会直接恢复到就绪状态
进入到阻塞状态的几种方式 :
            1. sleep()
            2. join()
            3. wait()
            4. IO
        进入线程就绪状态的方式:
            1. start()
            2. yield()
            3. 线程切换
            4. 阻塞接触
进入终止状态的方式:
            1.stop 已经过时,不推荐使用    2.正常之间完毕       3.添加标识判断  --> 推荐
sleep(ms) :  1s = 1000ms
            线程休眠|睡眠
            会进入到阻塞状态,当指定的ms数结束,线程会恢复到就绪状态
            抱着资源睡觉
            让出cpu的资源
            抱着是指对象的资源|锁
        作用 :
            1) 模拟网络延迟
            2) 方法问题的可能性
多线程
        三高: 高可用  高性能   高并发
        thread 类
            线程是程序中执行的线程。 Java虚拟机允许应用程序同时运行多个执行线程。
        多线程:
            多任务执行,多条路径可以执行
        多线程的优点:
            提高效率
        进程 与 线程 之间的区别:
            进程: 系统中的应用程序,一个进程之间包含1~n个线程,进程具有自己的资源,内存空间,进程是资源分配的最小单位
            线程: 一个程序中的顺序流,多个线程共享一个进程的资源和数据空间,每一个线程具有自己的程序计数器,线程是cpu调度的最小单位
        学习的目标:
            1.线程的创建于开启  *****
            2.线程的状态 : 新生  就绪   运行   阻塞   终止
            3.线程安全  *****
            4.线程通信  wait() notify()
       线程的创建：
        1.继承Thread,重写run()方法,定义线程体 + start()
        2.实现Runnable接口,重写run()方法 + start()  --> 推荐
        3.juc包下Callable接口,重写call()方法
public class Class001_Thread extends Thread{
    public static void main(String[] args) {
        //创建线程
        Class001_Thread th = new Class001_Thread();
        //开启线程 start() 可以被cpu调度了
        th.start();
        for(int i=1;i<=20;i++){
            System.out.println("一边讲课....");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //思考:
        //1) 不使用start()开启线程,直接调用run()方法
                //会出问题，但是不报错
        //2)start开启位置是否可以修改?
                //可以，但是也是的，会出问题
    }
    /*
        run() 定义线程体
     */
    @Override
    public void run() {
        for(int i=1;i<=20;i++){
            System.out.println("一边喝水....");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
实现Runnable接口，重写run方法+start（）
        1.类是单继承，接口多实现
        2.可以实现资源共享
//创建线程
        Thread th = new Thread(new Class002_Thread());
        //开启线程
        th.start();
        //new Class002_Thread().run();  //方法的调用,不是线程的开启
        for(int i=1;i<=20;i++){
            System.out.println("一边陪女朋友");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /*
        定义线程体
     */
    @Override
    public void run() {
        for(int i=1;i<=20;i++){
            System.out.println("一边打游戏");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
同步块
        synchronized(对象){
            同步代码段;
        }
        ()-->
            this
            类
            资源
        注意:
            锁不变的内容
            自定义引用数据类型对象地址不变
            双重检查 double check可以提高效率
public class Class003_Web12306 implements Runnable{
    Tickets tickets = new Tickets();  //自定义引用数据类型的对象
    public void run() {
        //重复买票
        while(true){
            //同步块
            //ABC
                if(tickets.num<=0){
                    break;
                }
                System.out.println("------------------------");
                System.out.println("------------------------");
                System.out.println("------------------------");
                System.out.println("------------------------");
                System.out.println("------------------------");
            synchronized (tickets){
                //双重检查 double check
                if(tickets.num<=0){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"正在购买第"+ tickets.num-- +"张票");
              /*  try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
            }
            /*多次购买之间休眠一定时间*/
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Class003_Web12306 web = new Class003_Web12306();
        //创建线程
        Thread th1 = new Thread(web,"优菈");
        Thread th2 = new Thread(web,"魈");
        Thread th3 = new Thread(web,"神里绫华");
        th1.start();
        th2.start();
        th3.start();
    }
}
//票
class Tickets{
    int num = 100;
}
Priority 线程的优先级
        线程的优先级越高,有限执行的可能性越大
        1~10 线程优先级的数值范围
        默认5    NORM_PRIORITY
        最小1    MIN_PRIORITY
        最大10   MAX_PRIORITY
        setPriority(int) 设置一个线程的优先级
        getPriority() 获取一个线程的优先级
public class Class006_Priority implements Runnable{
    public static void main(String[] args) {
        Class006_Priority  pri = new Class006_Priority();
        Thread th1 = new Thread(pri,"A");
        Thread th2 = new Thread(pri,"B");
        Thread th3 = new Thread(pri,"C");
        th1.setPriority(1);
        th3.setPriority(Thread.MAX_PRIORITY);
        System.out.println(th1.getPriority());
        System.out.println(th2.getPriority());
        System.out.println(th3.getPriority());
        th1.start();
        th2.start();
        th3.start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
其他定义线程体的方式
//内部类
    static class Inner implements Runnable{
        @Override
        public void run() {
            for(int i=1;i<=20;i++){
                System.out.println("一边吸烟...");
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) {
        new Thread(new Inner()).start();
        //匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<=20;i++){
                    System.out.println("一边烫头...");
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        //lambda表达式
        new Thread(() -> {
                for(int i=1;i<=20;i++){
                System.out.println("一边洗澡...");
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        for(int i=1;i<=20;i++){
            System.out.println("一边喝酒...");
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
yield 礼让线程 高风亮节
        当一个线程调用yield,让出cpu的资源,进入到就绪状态
        静态方法
public class Class002_Yield implements Runnable{
    public static void main(String[] args) {
        new Thread(new Class002_Yield(),"A").start();
        new Thread(new Class002_Yield(),"B").start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始了");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"结束了");
    }
}
join() 插队线程
    join(ms) 插队指定的ms数
    成员方法join,线程对象.join() 当前线程对象插队
    注意: 先就绪,后插队
new Thread(new SHI()).start();
}}
class SHI implements Runnable{
    @Override
    public void run() {
        System.out.println("老王要和老庄决斗！");
        System.out.println("老庄接了！！！！！");
        //创建老庄线程
        Thread t=new Thread(new ZHUANG());
        t.start();
        try {
           t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("老庄不依不饶..继续进攻");
        System.out.println("老庄获胜............");
    }
}
class ZHUANG implements Runnable{
    @Override
    public void run() {
        System.out.println("老王打了老庄一拳");
        System.out.println("老庄中拳了！！！");
        for (int i=1;i<=10;i++){
            System.out.println("老庄眩晕了"+i+"秒");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("老庄反击了，出拳！");
        System.out.println("老王中拳了..流血了");
    }
}
void interrupt() 为线程添加一个中断标识
    boolean isInterrupted() 测试此线程是否已被中断,是否已经调用过 interrupt()方法添加中断标识,是->true 不是->false
    static boolean interrupted() 测试当前线程是否已被中断, 是否已经调用过 interrupt()方法添加中断标识,是->true 不是->false,同时会复位标识
    注意: 一个线程如果进入终止状态,线程的中断标识会复位
        sleep--> InterruptedException - 如果有任何线程中断了当前线程。
public class Class004_Interrupt implements Runnable{
    @Override
    public void run() {    
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=1;i<=100;i++){
            if(Thread.interrupted()){
                System.out.println("--------->"+Thread.currentThread().isInterrupted());
                System.out.println("结束");
                break;
            }
            System.out.println(i);
        }
    }
    public static void main(String[] args) {
        Thread th = new Thread(new Class004_Interrupt());
        //就绪
        th.start();
        System.out.println(th.isInterrupted());
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //为th线程添加中断标识
        th.interrupt();
        System.out.println(th.isInterrupted());
    }
}

Abaiyu321
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java多线程性能浅析
wangluo23的专栏
01-03 384
<br />今天看见je上一帖，对于上亿数据求和的算法，采用多线程到底快还是慢，我认为需要按情况而定。<br />1.单核，无IO，网络等资源操作情况下<br />   结果：多线程比单线程理论上要慢<br />   原因：多线程启动线程需要消耗cpu资源，多线程只是把这一计算过程分片，在同一时刻只会有一个线程占有cpu，所以采用多线程不但在启动时耗费资源，在线程调度上同样也耗费时间。所以单线程比多线程理论上要快。<br />2.单核，有IO，网络等资源操作情况下<br />   结果：多线程比
多线程的简单描述
08-22
java多线程简单的描述以及线程的安全、并发，同步机制
1.介绍多线程
dilinying2838的博客
01-26 103
多线程 多线程是用来做什么的，我想举一个例子简单说明一下。 我正在工作，但是到中午了，饿了，但是去做饭就必须停下手中的工作。 而做饭又是一件非常耗时的事情，在做饭的时候，工作就处于停滞状态。 这就是串行程序的执行方式。 工作 ------> 停止工作 ------> 做饭 而随着社会的发展，外卖行业的发展，我们可以打电话订外卖。 做饭本身交给了别人，解放了自己的时间，所以工作...
多线程的介绍
yzjcsdn的博客
02-01 394
1、多线程运行的原理 多线程能够实现主要是 CPU在线程中做时间片的切换。 其实真正电脑中的程序的运行不是同时在运行的。 CPU负责程序的运行，而CPU在运行程序的过程中某个时刻点上，它其实只能运行一个程序,而不是多个程序。 而CPU它可以在多个程序之间进行高速的切换。而切换频率和速度太快，导致人的肉眼看不到。 每个程序就是进程， 而每个进程中会有多个线程，而CP
多线程(一) 多线程介绍及基本使用
淡淡的倔强的博客
03-26 2154
<一>多线程介绍  程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。   进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。   如：运行中的QQ，运行中的MP3播放器。   程序是静态的，进程是动态的。   线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执
多线程的基本介绍
沙惧心涸
05-25 546
一、进程和线程1、什么是进程？进程：是指系统中正在运行的一个应用程序。          每个进程之间是独立的，均运行在其专用且受保护的内存空间内。         2、什么是线程？线程：一个进程要想执行任务，必须得有线程（每一个进程至少要有一条线程）。          线程是进程的基本执行单元，一个进程（程序）的所有任务都在线程中执行。          例如：酷狗音乐播放歌曲、迅雷下载电影，...
c++多线程
02-20
一个进程中可以同时运行多个线程，每个线程可以执行不同的任务，这就是所谓的多线程。同一进程中的多个线程将共享该进程中的全部系统资源，如虚拟地址空间、文件描述符和信号处理等，但是同一个进程中的多个线程都有...
Python多线程爬虫
11-07
Python多线程爬虫 功能描述 使用python编写一个网站爬虫程序，支持参数如下： spider.py -u url -d deep -f logfile -l loglevel(1-5) --testself -thread number --dbfile filepath --key=”HTML5” 参数说明： -...
多线程.txt
05-15
多线程入门，多线程基础知识，描述了Synchronized的线程互斥原理，和Single Threaded Execution模式，符合基础入门的用户可以好好学习，加深理解
多线程了解
01-02
java多线程、线程池详细教程，Executor框架的简单介绍。
多线程简述
weixin_45714175的博客
05-01 343
多线程 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录多线程前言一、线程与进程二、同步与异步二、并发与并行1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参
多线程的详细介绍
编程人生
04-20 554
多线程全面详解总结 一、多线程是什么？为什么要用多线程？ 　　介绍多线程之前要介绍线程，介绍线程则离不开进程。 　　首先 进程 ：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元； 　　线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。 多线程：一个进程中不只有一个线程。 　 为什么...
多线程简单介绍
天涯~的博客
04-15 250
线程  线程被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果您的应用程序涉及到复杂的和耗时的操作，那么设置不同的线程执行路径往往是有益的，每个线程执行特定的工作。 线程是轻量级进程。一个使用线程的常见实例是现代操作系统中并行编程的实现。使用线程节省了 CPU 周期的浪费，同时提高了应用程序的效率。 到目前为止我们编写的程序是一个单线程作为应用程序的运行实例的单一的过程运行的。但
多线程介绍（归纳）
xasasaa的博客
03-27 606
线程和进程 进程就是计算机中正在进行的一个独立的应用程序，进程是一个动态的概念必须是进行状态，如果一个应用没有启动，那就不是进程 线程就是组成进程的基本单元，可以完成特定的功能，一个进程可以有多个线程组成 进程和线程的区别： 1、内存空间上的区别： 进程是有独有的内存空间，每个进程之间是相互独立的，互不影响 线程有共享的内存空间（也有私有空间） 2、安全性 进程是相互独立的，一个进程的奔溃不会影响到其他的进程，进程是安全 线程存在内存空间共享，一个线程的奔溃可能会影响到其他的线程的执行，线程的安全是不如进程
多线程简单介绍（摘记）
Curtain
06-25 615
按照JDK文档的描述， 如果池中的实际线程数小于corePoolSize,无论是否其中有空闲的线程，都会给新的任务产生新的线程如果池中的线程数>corePoolSize and 如果池中的线程数＝maximumPoolSize，则有空闲线程使用空闲线程，否则新任务放入workQueue。（线程的空闲只有在workQueue中不再有任务时才成立） ThreadPoolExecutor中有方法
多线程概述及简单用法
renrenzhong的博客
01-15 339
多线程概述 多线程引入 把备注部分的代码通过画图解释一下调用流程。这个程序只有一个执行流程，所以这样的程序就是单线程程序。   假如一个程序有多条执行流程，那么，该程序就是多线程程序。 接下来我们来看看到底什么是多线程     多线程的和进程的介绍 1:要想了解多线程，必须先了解线程，而要想了解线程，必须先了解进程，因为线程是依赖于进程而存在。   2:什么是进程? 通过任
多线程的理解
weixin_56961911的博客
01-10 725
多线程的理解
1、多线程简单介绍
meiyongdesan的博客
05-28 331
概述 多线程，顾名思义也就是说多个线程共同执行来保证应用的稳定性和可用性，现如今几乎所有的应用都采用多线程模式。JAVA 语言从一开始就支持多线程，并通过并发包（java.util.concurrent）封装了一系列和线程有关的JAVA类。作为开发者，我们在使用这些并发包的时候也应该清楚其中的原理，这样以后在遇到问题时也可以尽快找出原因。 多线程 本篇我们主要通过以下三个模块简单的介绍多线程： 多线程的发展史 多线程带来的挑战 并发和并行 1、多线程的发展史 在最开始的单CPU时代，单时间点只能执行
大白话描述如何理解多线程
c_shell_python的博客
11-18 256
多线程就是多条线程，多条线程一起工作避免不了资源抢占的问题，互斥锁之类的同步机制是为了避免这种问题。 什么场景下需要使用多线程。 比如大家最常用的迅雷下载，如果只是单线程工作，将可能出现界面响应缓慢，卡死之类的问题，造成用户体验差。 如果我们做一个下载器，用多线程工作，多线程负责下载之类的耗时操作，主线程展示界面，响应用户事件。 用户下载一个东西A，就开辟一条线程A去处理，再下载一个东西B就再开一条线程B，因为A、B线程互不影响，各自独立， 如果需要使用到可能都会用到的变量，就加上互斥锁去同步。 想到
C语言多线程批量加密文件过程描述
最新发布
05-11
C语言中可以使用多线程来加速批量加密文件的过程，具体步骤如下： 1. 使用多线程库，如pthread库，创建多个线程。 2. 每个线程读取一个文件，调用加密函数对文件进行加密。 3. 如果有多个CPU核心，可以将线程绑定...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值