多线程（2）

最新推荐文章于 2023-06-15 17:40:13 发布
最新推荐文章于 2023-06-15 17:40:13 发布
阅读量237 收藏
点赞数
分类专栏： java高级特性 文章标签： 多线程 java高级特性
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dylan_wf/article/details/78425862
版权
线程的状态：

线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。
这里写图片描述

1.新建状态(New)：

当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码。

2.就绪状态(Runnable)

一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。

处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。

3.运行状态(Running)

当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。

4.阻塞状态(Blocked)

线程运行过程中，可能由于各种原因进入阻塞状态:
1>线程通过调用sleep方法进入睡眠状态；
2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
3>线程试图得到一个锁，而该锁正被其他线程持有；
4>线程在等待某个触发条件；
……
所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。

5.死亡状态(Dead)

有两个原因会导致线程死亡：
1) run方法正常退出而自然死亡，
2) 一个未捕获的异常终止了run方法而使线程猝死。
为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false。

案例：

public class MyRunnable implements Runnable{//继承Runnable接口
    //重写run()方法
    @Override
    public void run() {

        try {
            System.out.println("线程运行");
            Thread.sleep(500);
            System.out.println("线程在500毫秒后继续运行");
        } catch (InterruptedException e) {
            System.out.println("线程中断");
        }

    }
}

package test;

public class Test {

    public static void main(String[] args) {
        MyRunnable myrun=new MyRunnable();//创建MyRunnable类对象myrun
        Thread t1=new Thread(myrun);//将myrun作为Thread构造方法的参数传入
        System.out.println("新建线程t1");
        Thread t2=new Thread(myrun);
        System.out.println("新建线程t2");
        t1.start();//启动线程
        System.out.println("新建线程t1就绪");
        t2.start();
        System.out.println("新建线程t2就绪");
    }
}
线程的调度

线程调度是指按照特定机制为多个线程分配CPU使用权。

线程的优先级：
同一时刻多个线程处于运行状态时，需要排队等候cpu资源，每个线程会自动获取一个优先级，优先级的高低反映了线程的重要程度或者紧急程度，一般情况下，优先级高的线程获得CPU资源的概率较大，但结果不是绝对的。
线程优先级用1-10表示，1优先级最低，十最高，默认值是5。对应Thread类的公用静态常量。

public static final int NORM_PRIORITY=5;
public static final int MAX_PRIORITY=10;
public static final int MIN_PRIORITY=1;

每个线程的优先级都介于Thread.MAX_PRIORITY 和 Thread.MIN_PRIORITY之间。
也可以手动设置，通过getPriority（）方法获取，setPriority( )方法更改。

public class Test {

    public static void main(String[] args) {
        MyRunnable myrun=new MyRunnable();//创建MyRunnable类对象myrun
        Thread t1=new Thread(myrun,"线程1");//将myrun作为Thread构造方法的参数传入
        Thread t2=new Thread(myrun,"线程2");
        t1.setPriority(3);//设置线程优先级
        t2.setPriority(5);
        System.out.println("线程1优先级："+t1.getPriority());//获取线程优先级
        System.out.println("线程2优先级："+t2.getPriority());
        t1.start();//启动线程
        t2.start();
    }
}

线程的休眠：
程序允许一个线程进行暂时休眠，调用Thread.sleep(毫秒)方法。sleep()方法会让当前线程停止执行，由运行状态进入不可运行状态，休眠时间后会再次进入可运行状态，调用sleep()需处理InterruptedException异常。

public class Wait {
public static void bySec(long s){
    for(int i=0;i<s;i++){
        System.out.println(i+1+"秒");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
}
public class ThreadDemo {

    public static void main(String[] args) {
        System.out.println("Wait");
        Wait.bySec(6);
        System.out.println("Start");
    }

}

线程的强制运行：
join()方法使当前占用cpu正在运行的线程暂停执行，等待调用该方法的线程结束后再继续执行本线程。

案例：

public class MyRunnable implements Runnable{//继承Runnable接口
    //重写run()方法
    @Override
    public void run() {

        for(int i=1;i<20;i++){
            try {
                Thread.sleep(1000);//增加线程交替执行的概率
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }   

    }
}
package test;

public class ThreadJoin {

    public static void main(String[] args) {
         System.out.println("线程强制执行");
         Thread t=new Thread(new MyRunnable());
         t.start();
         for(int i=0;i<20;i++){//main方法写的程序就是主线程
             if(i==5){
                 try {
                    t.join();//阻塞主线程，子线程强制执行
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
             }   
             try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
             System.out.println(Thread.currentThread().getName()+"运行"+i);
         }
    }

}

线程的礼让：
yield()方法可以暂停当前线程执行，允许其他具有相同优先级的线程获得运行机会，该线程仍处于就绪状态 不转为阻塞状态。此时，系统选择其他相同或者高优先级的线程执行，如果当没有相同或者高优先级的线程执行时，该线程继续执行。

注意： 礼让只是提供一种可能性，不保证一定会实现，因为礼让线程还是处于就绪状态，仍有被线程调度程序再次选中的可能。

案例：

public class MyRunnable implements Runnable{//继承Runnable接口
    //重写run()方法
    @Override
    public void run() {

        for(int i=1;i<20;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i==3){
                System.out.println("线程礼让");
                Thread.yield();
            }
        }   

    }
}

package test;

public class ThreadJoin {

    public static void main(String[] args) {
         System.out.println("线程强制执行");
         Thread t=new Thread(new MyRunnable());
         Thread t1=new Thread(new MyRunnable());
         t.start();
         t1.start();

    }

}
线程的同步：

一个线程类要是通过实现Runnable接口实现的，那么类中的属性很可能被多个该类型的线程对象共享，可能引发线程不安全问题（数据不安全）。这时就必须使用同步。

当两个或多个线程同时访问一个资源时，需要以某种顺序来确保该资源某一时刻只能被一个线程使用，这就是线程的同步。

采用线程同步来控制线程执行有两种方式，同步方法和同步代码块，使用synchronized来实现：

1.同步方法：
使用synchronized修饰的方法控制对成员类变量的访问，每个类实例对应一把锁，一旦方法执行就独占该锁，方法返回时释放锁，被阻塞的线程获得该锁，重新进入可执行状态。确保了同一时刻对应一个实例避免了类成员变量访问冲突。

案例：

package Test;

public class Money implements Runnable{
    private static int count=500;//剩余取款金额，注意是static类型进行全局共享
    public void run(){
        //每个线程执行5次
        for(int i=1;i<6;i++){
            take();
        }
    }
    synchronized public void take(){    

            if(count>0){
                System.out.println(Thread.currentThread().getName()+"准备取款");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"完成取款");
            }
            else{
                System.out.println("余额不足以支付"+Thread.currentThread().getName()+"的取款，余额为0");
            }
            count=count-100;

    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
                Money money=new Money();
                Thread zhang=new Thread(money,"张三");
                Thread wife=new Thread(money,"张三的妻子");
                zhang.start();
                wife.start();
    }

}

2.同步代码块:
可以更精准的限制访问区域，更高效。

package Test;

public class Money implements Runnable{
    private static int count=500;//剩余取款金额
    public void run(){
        //每个线程执行5次
        for(int i=1;i<6;i++){
            take();
        }
    }
    public void take(){ 
            synchronized(this){
            if(count>0){
                System.out.println(Thread.currentThread().getName()+"准备取款");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"完成取款");
            }
            else{
                System.out.println("余额不足以支付"+Thread.currentThread().getName()+"的取款，余额为0");
            }
            count=count-100;
            }   
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
                Money money=new Money();
                Thread zhang=new Thread(money,"张三");
                Thread wife=new Thread(money,"张三的妻子");
                zhang.start();
                wife.start();
    }

}

static在同步中的应用：静态变量static被所有该类的对象所共享

package test;

public class MyRunnable implements Runnable{//继承Runnable接口
    //静态变量static被所有该类的对象所共享
    private static int count=10;//剩余票数
    //注意，一定要定义为static静态全局变量，这样才能数据统一，不会每次不同的对象进去都是原来的初始值
    private static int num=0;//买到第几张票
    //重写run()方法
    @Override
    public void run() {
        for(int i=0;i<5;i++){//每个进程循环5次,即对应每人最多只能抢票5次
                sale();//调用sale方法
        }
    }
    private synchronized void sale() {
        if(count<=0){
            System.out.println(Thread.currentThread().getName()+"没买到票，票买完了！");
            return;//方法结束并退出，返回调用该方法的语句处
        }
        num++;
        count--;
        try {
            Thread.sleep(500);//模拟网络延时
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"抢到第"+num+"张票，剩余"+count+"张票");
    }
}

package test;

public class Test1 {

    public static void main(String[] args) {
        MyRunnable my=new MyRunnable();
        Thread t1=new Thread(my,"抢票代理");
        Thread t2=new Thread(my,"黄牛");
        Thread t3=new Thread(my,"小张");
        t1.start();
        t2.start();
        t3.start();
    }

}
Dylan_wf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程2
08-06
标题“多线程2”指的是在编程领域中关于多线程技术的深入探讨。多线程是计算机程序设计中的一项关键技术，特别是在并发处理和优化性能方面。它允许一个应用程序同时执行多个不同的任务，从而提高系统资源的利用率和...
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
WF4.0与多线程
一切安好
02-15 1229
在WF4.0中,可以使用WorkflowApplication与WorkflowInvoker创建并启动实例. 但两者在宿主中的线程方式是不一样的 使用WorkflowInvoker启动工作流时,工作流将附加到宿主的线程中执行 使用WorkflowApplication启动工作流，工作流实例将在宿主线程之外的另一个线程中运行,使用的是线程池方式 现在用实例证明： 工作
算法题1（C++）：多线程计算从1到N的所有数字的平方和，其中N为用户输入的正整数（使用多线程来加速）。
最新发布
qq_55906687的博客
06-15 302
程序应该能够处理较大的N值，确保计算结果的准确性和效率。“程序应具有良好的线程同步和数据共享机制，以避免竞争条件和数据不致的问题。编写一个程序，使用多线程计算从1到N的所有数字的平方和，其中N为用户输入的正整数。使用多线程来加速计算过程。
java：编写10个线程，第一个线程从1加到10，第二个线程从11加到20……第十个线程从91加到100， 最后再,10个线程结果相加
热门推荐
popping_w的博客
03-12 1万+
在生活中，人体可以同时进行各项生命活动。例如，人体可以同时进行呼吸、血液循环等等… 当我们在编写程序时，这些行为我们可以抽象为并发，而将并发完成的每一件事称为线程。 线程创建的两种传统方式 方式一：继承Thread类 1.创建Thread类的子类 2.重写Thread类的run（）方法，将当前线程要执行的操作声明在run（）方法内！ 3.实例化Thread类的子类 4通过Thread类的子类对对象...
求解数组元素的平方
ibianma的博客
08-16 1634
这是一道快手面试算法题: 给定一个有序的整数数组（包含正数，负数，零，可以重复） 问这个数组的平方有多少种情况？ 例如;{-1,-1,0,1,1} 有{1,0}两种情况。 {-4,-2,0,2,4,5}有{16,4,0,25}四种情况。 要求：时间复杂度为O(n),空间复杂度为O(1); ...
用while语句显示1~10的平方。
m0_54632021的博客
02-07 4995
#include"stdio.h" void main() { int i=1; while(i<=10) { printf("%d*%d=%d\n",i,i,i*i); i++; } }
C#泛型参数多线程与复杂参数多线程2
07-19
最近用多线程用的比较多自己走了一些弯路，分享出来希望大家少走弯路，C#中的多线程有两个重载，一个是不带参数的，一个是带参数的，但是即便是带参数的多线程也不支持泛型，这使得使用泛型参数多线程的时候很不方便...
java多线程2
10-24
某些情况下，我们会遇到这样的情况：线程A运行过程中，在某个地方需要等待线程B运行的结果，才能继续运行。这时我们需要用到线程异步通信的方法。
qt websocket 客户端 多线程使用
09-16
qt 使用QWebSocket 创建websocket客户端来读取数据，异步链接，并且放入到线程中去执行，线程池的基础，代码使用两个用户，放入到一个线程中执行，同理，可以多个用户放入到多个线程中执行，为线程池执行websocket ...
大漠多线程模板_大漠_大漠多线程_
09-30
2. **线程同步**：在多线程环境中，防止数据竞争和确保资源安全访问是至关重要的。C#提供了多种同步机制，如`Mutex`、`Semaphore`、`Monitor`和`lock`关键字。模板可能内置了这些同步工具的使用，减少了因不当同步...
多线程测试
09-21
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。这极大地提高了软件的效率和响应性，特别是在现代多核处理器的环境下。本主题将深入探讨多线程的实现方式及其与单线程的对比...
WPF多线程实例
05-08
在Windows Presentation Foundation（WPF）开发中，多线程是一个重要的技术，特别是在处理大量数据或进行耗时操作时，为了保持用户界面（UI）的响应性，通常会使用多线程来实现非UI任务。本实例是关于如何在WPF应用...
安卓多线程
04-16
安卓多线程，安卓高级开发中，必备技能，项目开发中都要使用
C++多线程编程.pdf
09-05
C++多线程编程
Java并发学习之中的一个——线程的创建
weixin_34015336的博客
03-27 90
本文是学习网络上的文章时的总结，感谢大家无私的分享。 1、与每一个Java语言中的元素一样，线程是对象。在Java中，我们有两种方式创建线程： a、通过直接继承thread类，然后覆盖run方法。 b、构建一个实现Runnable接口的类，然后创建一个thread类对象并传递Runnable对象作为构造參数 代码例如以下 package chapter; /** * ...
请使用继承Thread类的方式定义一个线程类，在run()方法中使用循环变量i遍历1--1000所有的数字。
weixin_52067329的博客
03-27 1002
/* 请使用继承Thread类的方式定义一个线程类，在run()方法中使用循环变量i遍历1--1000所有的数字。 */ public class xo { public static void main(String[] args) { // 启动自定义线程 new xoThread().start(); // 主线程输出 for (int k = 0; k < 1000; k++) { System.
java线程：通过Thread类创建线程（上）
Thumb_的博客
10-20 169
什么是进程？ 进程是指可执行程序并存放在计算机存储器的一个指令序列，它是一个动态执行的过程。 什么是线程？ 线程是比进程还要小的运行单位，一个进程包含多个线程，线程可以看作一个子程序。 当一个类继承Thread，它就是一个线程了。 package java_thread; //继承Thread就是一个线程了 class MyThread extends Thread{ public void run(){ System.out.println(getName() + "该线程正在进行
使用两个线程交替打印1到10的两种实现方式
dachui的博客
04-05 4712
@感谢小毛豆 今天一个同学说在面试的时候,遇到了一个面试题,两个线程交替打印1到10,感觉还是很有意思的就发表一下 实现Runnable()接口 要实现交替打印意味着者两个线程要交替执行某一段相同代码,以相同的逻辑方式等待和唤醒其他的线程,首先写执行的逻辑代码 package method1; /** * Create by Kenson on 2019/4/3 */ public clas...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值