正文

多线程线程状态和案例演示(代码片段)

godles  godles  2023-05-05  528

关键词：

线程的几种状态

初始（NEW）：新创建了一个线程对象，但还没有调用start()方法
运行（RUNNABLE）：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”
阻塞（BLOCKED）：表示线程阻塞于锁
等待（WAITING）：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）
超时等待（TIMED_WAITING）：该状态不同于WAITING，它可以在指定的时间后自行返回
终止（TERMINATED）：表示该线程已经执行完毕

线程状态的转换

技术图片

线程的生命周期

新生（New）：代表线程的对象已经被初始化，但尚未运行run方法。
可执行（Runnable）：线程正在运行run方法，但这只说明线程目前处于的状态，如果系统没有能力拨出CPU执行时间给线程，线程就“不执行”，这里的“不执行”不代表“停滞”或“死亡”。
停滞（Blcked）：线程是可以执行的，但由于某些因素的阻碍处于停滞状态，系统排程器略过了应给的CPU执行时间。
死亡（Dead）：线程的正式结束方式，run方法执行完毕并返回。

生产者消费者模式

public class MainMethod 

    /**
     * 1、产品/食物
     * 2、缓冲区/柜台的大小
     * 3、生产者/厨师
     * 4、消费者/顾客
     */
     //主方法
    public static void main(String[] args) 

        // 实例化缓冲区/柜台
        BlockingQueue<Product> blockingQueue = new ArrayBlockingQueue<Product>(8);

        // 实例化生产者/厨师
        Producer producer = new Producer(blockingQueue);
        Thread thread1 = new Thread(producer);
        thread1.start();

        // 实例化消费者/顾客
        Consumer consumer = new Consumer(blockingQueue);
        Thread thread2 = new Thread(consumer);
        thread2.start();

    





//产品
public class Product 

    public String name;

    public Product(String name) 
        this.name = name;
    

    public String getName() 
        return name;
    

    public void setName(String name) 
        this.name = name;
    




//生产者
public class Producer implements Runnable 

    /**
     * 缓冲区/柜台的大小
     */
    public BlockingQueue<Product> blockingQueue;

    public Producer(BlockingQueue<Product> blockingQueue) 
        this.blockingQueue = blockingQueue;
    

    /**
     * 模拟生产者生产产品
     */
    @Override
    public void run() 
        int i = 0;
        while (true) 
            Product product = new Product("产品名称" + i++);
            try 
                this.blockingQueue.put(product);
             catch (InterruptedException e) 
                e.printStackTrace();
            
            System.out.println("生产者生产了产品" + product.getName());
        
    



//消费者
public class Consumer implements Runnable 

    /**
     * 缓冲区/柜台的大小
     */
    public BlockingQueue<Product> blockingQueue;

    public Consumer(BlockingQueue<Product> blockingQueue) 
        this.blockingQueue = blockingQueue;
    

    /**
     * 模拟消费者消费产品
     */
    @Override
    public void run() 
        while (true) 
            Product product  = null;
            try 
                product = this.blockingQueue.take();
             catch (InterruptedException e) 
                e.printStackTrace();
            
            System.out.println("消费者消费了产品" + product.getName());

龟兔赛跑

public class Race implements Runnable
    //胜利者
    private static String winner;




    @Override
    public void run() 
        for (int i = 0; i <= 100; i++) 
            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子")&&i%10==0)
                try 
                    Thread.sleep(10);
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
            //判断比赛是否结束
            boolean flag=gameover(i);
            if (flag)
                break;
            
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        
    

    //判断比赛是否结束
    private boolean gameover(int steps)
        while (true)
            //已经存在了胜利者
            if (winner!=null)
                return true;
            else
                if (steps==100)
                   winner = Thread.currentThread().getName();
                    System.out.println("胜利者是"+winner);
                    return true;
                
            
            return false;

        
        

    public static void main(String[] args) 
        Race race = new Race();
       new Thread(race,"乌龟").start();
       new Thread(race,"兔子").start();

第一个线程用来计算2～100000之间的素数的个数，第二个线程用来计算100000～200000之间的素数的个数

package Demo02;

public class ThreadTest extends Thread 
    public static void main(String[] args) 
        Thread1 t1 = new Thread1();
        t1.start();
        Thread2 t2 = new Thread2();
        t2.start();
    

class Thread1 extends Thread 
    public void run() 
        System.out.println("2 到 100000之间的素数有   " + getSum(2, 100000)+" 个");
    

    //获取素数个数的方法
    public int getSum(int inputMin, int inputMax) 
        int sum = 0;
        for (int i = inputMin; i <= inputMax; i++) 
            if (isPrime(i)) 
                sum++;
            
        
        return sum;
    

   //判断是否为素数
    public static boolean isPrime(int input) 
        for (int i = 2; i < input; i++) 
            if (input % i == 0) 
                return false;
            
        
        return true;
    


//让第二个线程继承第一个线程重写run方法即可
class Thread2 extends Thread1 
    public void run() 
        System.out.println("100000 到 200000 之间的素数有 " + getSum(100000, 200000)+" 个");

模拟多个人通过一个山洞的场景.这个山洞每次只能通过一个人,每个人通过山洞的时间为5秒,有10个人同时准备过此山洞,显示每次通过山洞的人的姓名和顺序.

public class ThreadTest 
    public static void main(String[] args) 
        Cave cave = new Cave();
        int num=0;
        for (int i = 0; i < 10; i++) 
            Thread thread = new Thread(cave, "狠人" +((int)(Math.random()*100)));//使用数学类随机生成一些整数编号来记录通过山洞人的姓名
            thread.start();

        
    


//山洞
class Cave implements Runnable 
    //定义两个常量来记录通过几人和已经通过几人
    int num=1;
    int count=0;
    @Override
    public void run() 
        synchronized ("") 
            System.out.println(Thread.currentThread().getName() + "	
是第"+(num++)+"个通过");
            System.out.println("已经通过了" + (++count) + "个人");
        

        try 
            Thread.sleep(5000);//延迟5s
         catch (InterruptedException e) 
            e.printStackTrace();

初识多线程(代码片段)

初识多线程前言一、操作系统1.冯诺依曼体系结构2.操作系统二、进程2.1操作系统管理进程2.2进程的组成2.3时间片2.4并行和并发2.5内核态和用户态2.6进程状态三、多线程3.1线程是什么？3.2进程和线程的区别3.3Java实现多线程3.4... 查看详情

多线程学习(基础篇)(代码片段)

文章目录一、多线程概述1.进程和线程之间的关系2.创建线程的方式3.Thread的几个常见属性4.中断一个线程5.获取当前线程引用6.线程的状态二、线程安全1.演示线程不安全2.如何避免线程安全问题3.synchronized关键字4.Java标准库中的线... 查看详情

多线程学习(基础篇)(代码片段)

多线程中的生产者消费者案例(代码片段)

...产者消费者Object类常用的方法方法功能voidwait()用于使得线程进入等待状态，直到其它线程调用notify()或notifyAll()方法voidwait(longtimeout)用于进入等待状态，直到其它线程调用方法或参数指定的毫秒数已经过去为止voidnotify()用... 查看详情

线程创建_同步_通信(代码片段)

目录1.基本概念：程序、进程、线程2.并行和并发3.创建线程的两种方式3.1通过继承Thread方式3.1.1步骤：3.1.2两个问题3.1.3案例演示3.2通过实现Runnable的方式3.2.1步骤3.2.2代码演示3.3两种方式的比较4.Thread类中常用方法4.1常用方法4.2线... 查看详情

线程八大基础核心四（线程生命周期）(代码片段)

1.引子在java多线程并发编程中，有八大基础核心。考考你：看看都有哪八大基础核心呢？它们分别是： 1.创建线程的方式 2.线程启动 3.线程停止 4.线程生命周期 5.线程相关的方法 6.线程相关的属性 7.线程异常处理 8.线程安全今天... 查看详情

java多线程-线程的状态和线程常用方法(代码片段)

线程共有五大状态1创建线程对象被创建就进入到新状态(new)2就绪调用线程的start()方法,线程进入就绪状态3运行线程进入运行状态,开始执行线程体代码4阻塞调用sleep,wait等方法时,线程进入阻塞状态,线程不再继续往下执行,阻塞事... 查看详情

多线程详解---（多案例实战）(代码片段)

多线程1、区分单线程和多线程单线程：就像是做饭，洗衣服，煮水，一个一个进行多线程：在单线程的基础上，可以考虑煮水的时候，洗衣服节约时间packagecom.kong.thread;//创建线程，重写run方法࿰... 查看详情

java多线程（详细了解java多线程机制）(代码片段)

每天进步一点点一、程序、进程、线程1.1什么是程序1.2什么是进程1.3什么是线程1.4进程和线程的区别二、创建线程的三种方式2.1继承Thread类重写run()方法具体实现获取线程ID和名称修改线程名称2.2实现Runnable接口实现run()方法具体... 查看详情

python应用实战-多线程应用案例(代码片段)

Python多线程的使用我们知道进程是资源分配的单位，线程是处理机调度的单位。下文就以简明的例子带大家理解线程，并使用Python实现多线程。比如在飞车程序中，我们在玩游戏的同时，还可以听到游戏为我们配置的背景音乐。... 查看详情

java多线程与并发(案例+应用)(代码片段)

文章目录1.传统创建线程的两种方式2.传统定时器技术3.传统线程互斥技术4.传统线程同步通信技术5.线程范围内共享变量概念和作用6.ThreadLocal类及应用技巧7.多个线程之间共享数据的方式8.Java原子性类的应用9.Java线程并发库的应... 查看详情

多线程多线程基础知识(代码片段)

文章目录1.认识线程（Thread）2.Thread类及常见方法2.1Thread常见构造方法2.2start和run方法的区别2.3Thread常见属性2.4中断线程2.5等待线程2.6休眠线程3.线程的状态3.1线程的所有状态3.2线程状态转移图1.认识线程（Thread）进... 查看详情

多线程多线程基础知识(代码片段)

c语言多线程演示(代码片段)

一.线程简介线程:线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。多线程：多线程是指程序中包含多个执行流，... 查看详情

c语言多线程演示(代码片段)

b站狂神说java笔记-多线程(代码片段)

目录狂神视频地址1.任务2.进程3.多线程4.Thread和Runnable小结5.案例：龟兔赛跑6.静态代理7.Lambda表达式8.线程状态9.线程休眠（sleep）10.线程礼让（yield）11.线程强制执行：（join）12.线程优先级13.守护(dae... 查看详情

并发和多线程--线程的生命周期/状态(代码片段)

　　线程的生命周期或者说状态其实不复杂，但是很多人的理解可能有错误，一个典型的误区，线程运行时的状态是Runnable，而不是Running，因为线程没有Running状态。线程的状态1、New：已创建，没启动。还没有执行start()2、Runnable... 查看详情

linux网络编程基础及多线程并发案例(代码片段)

...数bind listenaccept7.客户端基本函数 connect8.send和recv 8.多线程9.通信流程10.多线程并发样例程序 1.ip:端口 TCP/IP协议 AF_INET 查看详情