多线程(认识多线程、线程的常用操作方法)

最新推荐文章于 2023-07-03 19:31:17 发布
最新推荐文章于 2023-07-03 19:31:17 发布
阅读量5.8k 收藏 7
点赞数 1
分类专栏： j2se 文章标签： 多线程 thread class string java exception
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cz1029648683/article/details/6655526
版权
 

认识多线程

进程与线程：

进程是程序的一次动态执行过程，它经历了从代码加载、到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。

多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。

Java的多线程实现，有一下两种方式：

·继承Thread类

·实现Runnable接口

Thread类

Thread类是在java.lang包下定义的，一个类只要继承了Thread类，此类就称为多线程操作类。在Thread子类中，必须明确的腹泻Thread中的run()方法，此方法称为线程的主体。

·多线程的定义语法：

class 类名称 extends Thread {	//继承Thread类
	属性...;					//类中定义属性
	方法...;					//类中定义方法
	//覆写Thread中的run()方法，此方法是线程的主体
	public void run(){
		线程主体；
	}
}

如以下的一个类中就具备了多线程的操作功能：

class MyThread extends Thread	//继承自Thread类
{
	private String name;	//表示线程的名称
	public MyThread(String name){	
		this.name=name;	//通过构造方法配置name属性
	}
	public void run(){	//覆写run方法，作为线程的主体
		for(int i=0;i<10;i++){
			System.out.println(name+"运行，i="+i);
		}
	}
}

实例化该类以后，通过对象可以调用run方法：

public class ThreadDemo01 
{
	public static void main(String args[]){
		MyThread m=new MyThread("A");   //实例化MyThread类
		MyThread m1=new MyThread("B");
		m.run();   //调用run 方法
		m1.run();
	}
}

同过程序的运行结果可以发现，程序是先执行A后再执行B的，并没有达到所谓的并发执行的效果，如果是想要启动一个线程必须要使用Thread类中定义的start()方法。

public class ThreadDemo01 
{
	public static void main(String args[]){
		MyThread m=new MyThread("A");  //实例化MyThread类
		MyThread m1=new MyThread("B");
		m.start();   //调用Thread类中定义的start启动一个线程
		m1. start ();
	}
}

注意：如果当前线程已经启动了(就是说已经调用了start方法)，再次调用start方法就会出现java.lang.IllegalThreadStateException异常

Runnable接口

在Java中也可以通过实现Runnable接口的方式实现多线程，Runnable接口中只定义了一个抽象方法：

·public void run();

通过Runnable接口实现多线程：

class 类名称 implements Runnable	//实现Runnable接口
{
	属性...;						//类中定义属性
	方法...;						//类中定义方法
	public void run(){			//覆写Runnable接口中的run方法
		线程主体;
	}
}

如以下代码：

class MyThread implements Runnable	//继承自Thread类
{
	private String name;	//表示线程的名称
	public MyThread(String name){	
		this.name=name;	//通过构造方法配置name属性
	}
	public void run(){	//覆写run方法，作为线程的主体
		for(int i=0;i<10;i++){
			System.out.println(name+"运行，i="+i);
		}
	}
}
public class ThreadDemo02
{
	public static void main(String args[]){
		MyThread m1=new MyThread("A");	//实例化对象
		MyThread m2=new MyThread("B");
		Thread t1=new Thread(m1);	//实例化Thread类
		Thread t2=new Thread(m2);
		t1.start();	//启动线程
		t2.start();	
	}
}

以上代码通过实现Runnable接口实现了多线程，但是要注意的是，一个线程启动的方法是在Thread类中的start()方法，此时Runnable接口中是没有该方法的，所以要实例化Thread类，调用其start方法。

Runnable接口与Thread类的区别

使用Thread类在操作多线程的时候无法达到资源共享的目的，而使用Runnable接口实现的多线程操作可以实现资源共享。如以下的代码：

实现Runnable接口：

class MyThread implements Runnable	//继承自Thread类
{
	private int Number1=5;	//表示线程的名称

	public void run(){	//覆写run方法，作为线程的主体
	
					for(int i=0;i<100;i++){
						if(Number1>0)
					System.out.println("ticket"+Number1--);
				}
	}
}
public class ThreadDemo02
{
	public static void main(String args[]){
		MyThread m=new MyThread();
		new Thread(m).start();
		new Thread(m).start();
		
	}
}

此时可以发现启动了两个线程，但是票的总数是5。

继承自Thread类：

class MyThread extends Thread	//继承自Thread类
{
	private int Number1=5;	//表示线程的名称

	public void run(){	//覆写run方法，作为线程的主体
	
					for(int i=0;i<100;i++){
						if(Number1>0)
					System.out.println("ticket"+Number1--);
				}
	}
}
public class ThreadDemo03
{
	public static void main(String args[]){
		MyThread m1=new MyThread();
		MyThread m2=new MyThread();
		MyThread m3=new MyThread();
		m1.start();		//启动线程
		m2.start();		//启动线程	
		m3.start();		//启动线程
	}
}

此时启动了三个线程，票的总数就是15，因为在每一个MyThread对象中都包含各自的ticket属性。

Thread类与Runnable接口的使用结论

实现Runnable接口比继承Thread类有如下明显的优点：

·适合多个相同程序代码的线程去处理同一个资源。

·可以避免由于单继承局限所带来的影响。

·增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。

综合以上来看：开发中使用Runnable接口是比较合适的，应该充分使用其以上特性。

线程的状态

多线程在操作中也是有一个固定的操作状态的：

·创建对象：准备好了一个多线程的对象: Thread t=new Thread();

·就绪状态：调用了start()方法，等待CPU进行调度。

·运行状态：执行了run()方法。

·阻塞状态：暂时停止执行，可能将资源交给其它资源使用。

·终止状态(死亡状态)：线程执行完毕，不再进行使用。

线程的常用操作方法


取得当前线程的名称

程序可以通过currentThread()方法取得当前正在运行的线程的名称。代码如下：

class MyThread implements Runnable	//实现Runnable接口
{
	public void run(){	//覆写run 方法
		System.out.println(Thread.currentThread().getName()+"运行");
	}
}
public class currentThreadDemo
{
	public static void main(String args[]){
		MyThread m=new MyThread();	//实例化Runnable子类对象
		new Thread(m).start();	//让JVM为线程设置名称并启动
		new Thread(m,"线程").start();	//为线程设置名称并启动线程
		m.run();	//直接调用run方法 获得当前main方法线程名称
		//程序输出
		//Thread-0运行
		//main运行
		//线程运行
	}
}

由以上代码可以得知：如果不为一个线程设置名称，则JVN自动按Thread-0、Thread-1、Thread-2、….的格式为线程设置名称。注意：main方法的线程名称为main

扩展：既然主方法都是以线程的形式出现的，那么JAVA运行时至少应该是启动了两个线程。每当JAVA程序运行的时候，实际上都启动了一个JVM，每一个JVM实际上就是在操作系统中启动了一个进程，java本身具有垃圾收集机制，所以Java运行时至少启动了两个线程：

主线程、GC(垃圾回收的线程)

判断线程是否启动

判断线程是否启动使用isAlive()方法，返回boolean得到当前线程是否活动。

class MyThread implements Runnable	//实现Runnable接口
{
	public void run(){	//覆写run 方法
		System.out.println(Thread.currentThread().getName()+"运行");
	}
}
public class ThreadAliveDemo
{
	public static void main(String args[])throws IllegalThreadStateException{
		MyThread m=new MyThread();	//实例化Runnable子类对象
		Thread t=new Thread(m,"自定义线程");
		System.out.println("线程执行前："+t.isAlive());		//false
		t.start();
		System.out.println("线程启动之后："+t.isAlive());	//true
	}
}

线程的强制运行

在线程操作中，可以使用join()方法让一个线程强制运行，线程强制运行期间，其它线程无法运行，必须等待此线程完成之后才可以继续执行。

class MyThread implements Runnable	//实现Runnable接口
{
	public void run(){	//覆写run 方法
		for(int i=0;i<50;i++){
			System.out.println(Thread.currentThread().getName()+"运行,i="+i);
		}
		
	}
}
public class ThreadJoinDemo
{
	public static void main(String args[]){
		MyThread m=new MyThread();	//实例化Runnable子类对象
		Thread t=new Thread(m,"自定义线程");
		t.start();
		for(int i=0;i<50;i++){
			if(i>10)
				try{
				//join方法会出现异常
				t.join();
			}catch(InterruptedException e){
			}
			System.out.println("main线程运行，i="+i);
		}
	}
}

以上代码中，程序一开始自定义跟main线程会交替运行，但是当main线程中i+10时，就会强制的先执行自定义线程，待其执行完以后，再执行main线程，这就是线程的强制运行。

线程的休眠

在程序中允许一个线程进行暂时的休眠，直接使用Thread.sleep()方法即可。

class MyThread implements Runnable	//实现Runnable接口
{
	public void run(){	//覆写run 方法
		for(int i=0;i<50;i++){
			try{
				//sleep方法会出现异常
				Thread.sleep(1000);		//程序会暂停1000毫秒再执行
			}catch(InterruptedException e){
			}
			System.out.println(Thread.currentThread().getName()+"运行,i="+i);
		}
	}
}
public class ThreadSleepDemo
{
	public static void main(String args[]){
		MyThread m=new MyThread();	//实例化Runnable子类对象
		Thread t=new Thread(m,"自定义线程");
		t.start();
	}
}

以上的程序会间隔1秒钟执行一次。Sleep()方法就时暂时的休眠，指定了一定了的时间后程序会继续执行。

线程的中断

一个线程可以被另一个线程中断其操作的状态，使用interrupt()方法。

class MyThread implements Runnable	//实现Runnable接口
{
	public void run(){	//覆写run 方法
		
			try{
				//sleep方法会出现异常
				System.out.println("1、进入run方法");
				Thread.sleep(2000);		//程序会暂停1000毫秒再执行
				System.out.println("2、已经完成了休眠");
			}catch(InterruptedException e){
				System.out.println("3、休眠被终止！");
				return;		//返回方法调用处
			
			
		}
		System.out.println("4、run方法正常结束");
	}
}
public class ThreadInterruptDemo
{
	public static void main(String args[]){
		MyThread m=new MyThread();	//实例化Runnable子类对象
		Thread t=new Thread(m,"自定义线程");
		t.start();
			try{
				//sleep方法会出现异常
				Thread.sleep(10000);
			}catch(InterruptedException e){
			}
		
		t.interrupt();
	}
}

后台线程

在Java程序中，只要前台有一个线程在运行，则整个Java进程都不会消失，所以此时可以设置一个后台线程，这样即使Java进程结束了，此后台线程依然会执行。要想实现这样的操作，直接使用setDaemon()方法即可。

class MyThread implements Runnable{	// 实现Runnable接口
	public void run(){	// 覆写run()方法
		while(true){
			System.out.println(Thread.currentThread().getName() + "在运行。") ;
		}
	}
};
public class ThreadDaemonDemo{
	public static void main(String args[]){
		MyThread mt = new MyThread() ;	// 实例化Runnable子类对象
		Thread t = new Thread(mt,"线程");		// 实例化Thread对象
		t.setDaemon(true) ;	// 此线程在后台运行
		t.start() ;	// 启动线程
	}
};

此方法了解即可，不重要。

线程的优先级

优先级越高的线程，被执行的顺序就比较靠前，在Thread中存在三个常量：MAX_PRIORITY、

MIN_PRIORITY、NORM_PRIORITY执行顺序为：MAX_PRIORITY> NORM_PRIORITY>

MIN_PRIORITY、代码如下：

class MyThread implements Runnable	//实现Runnable接口
{
	public void run(){	
			System.out.println(Thread.currentThread().getName());
	}
}
public class ThreadPriorDemo
{
	public static void main(String args[]){
		Thread t1=new Thread(new MyThread(),"线程A");
		Thread t2=new Thread(new MyThread(),"线程B");
		Thread t3=new Thread(new MyThread(),"线程C");
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MIN_PRIORITY);
		t1.start();
		t2.start();
		t3.start();
	}
}

实际上：MAX_PRIORITY=10、 NORM_PRIORITY=5、MIN_PRIORITY=1

同步与死锁

先看如以下的代码:

class MyThread implements Runnable{
	int ticket=5;	//假设一共有5张票
	public void run(){	
		for(int i=0;i<50;i++){
			if(ticket>0){	 //还有票的话就继续卖
				try{
					Thread.sleep(500);	//为了保证正确，加入延迟
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				System.out.println("卖票：ticeket="+ticket--);
			}
		}
	}
}
public class synchronizedDemo02
{
	public static void main(String args[]){
		MyThread m1=new MyThread();	//定义线程对象
		new Thread(m1).start();		//定义Thread对象
		new Thread(m1).start();
		new Thread(m1).start();
	}
}

代码最终结果如下:

程序的问题：从运行结果中可以发现，程序中加入了延迟操作以后，票数会变为负数，出现这种情况的原因是：一个线程有可能在还没有对票数进行减操作之前，其它线程已经将票数减少了，这样一来就出现了票数为负的情况。

问题解决：如果想解决这种问题，就必须使用线程的同步操作，所谓的同步就是指多个操作在同一个时间段内只能有一个线程进行，其它线程要等待此线程完成之后才可以执行。

使用同步

要想解决资源共享的同步操作问题，可以使用同步代码块或者是同步方法两种方式完成。

同步代码块：

之前介绍了代码块分为四种：

1、  普通代码块：是直接定义在方法之中的。

2、  构造块：直接定义在类中，优先于构造方法执行，重复调用。

3、  静态块：使用static关键字声明：优先于构造块执行，只执行一次。

4、  同步代码块：使用synchronized关键字声明的代码块，成为同步代码块。

同步代码块格式：

Synchronized(同步对象){
    需要同步的代码;
}

同步代码块必须指明同步的对象，一般情况下会将当前对象进行同步，使用this表示。

使用同步后的代码：

class MyThread implements Runnable{
	int ticket=5;
	public void run(){	
		synchronized(this){		//同步代码块，同步当前对象
		for(int i=0;i<50;i++){
			if(ticket>0){
					try{
						Thread.sleep(300);
					}catch(InterruptedException e){
						e.getStackTrace();
					}
					System.out.println("卖票"+(ticket--));	
				}
			}
		}
	}
}
public class synchronizedDemo02
{
	public static void main(String args[]){
		MyThread m1=new MyThread();
		new Thread(m1).start();
		new Thread(m1).start();
		new Thread(m1).start();
	}
}

因为使用了方法的同步之后，在同一时间段内只能又一个线程执行，所以程序的执行效率会明显降低很多。

同步方法

除了可以将需要同步的代码设置成同步代码块之外，也可以使用synchronized关键字将一个方法声明成同步方法。

同步方法定义格式：

snchronized 方法返回值 方法名称(参数列表){};

使用同步方法以后的代码：

class MyThread implements Runnable{
	int ticket=5;
	public void run(){	
		for(int i=0;i<50;i++){
		this.sale();	//调用当前类中的同步方法
		}
	}
	public synchronized void sale(){	//同步方法
	if(ticket>0){
			try{
				Thread.sleep(300);
			}catch(InterruptedException e){
				e.getStackTrace();
			}
			System.out.println("卖票"+(ticket--));	
		}
	}
}
public class synchronizedDemo03
{
	public static void main(String args[]){
		MyThread m1=new MyThread();
		new Thread(m1).start();
		new Thread(m1).start();
		new Thread(m1).start();
	}
}

死锁

1、  共享时需要进行同步操作

2、  程序中过多的同步会产生死锁。

扩展

方法定义的完整格式：

访问权限{public、default、protected、private} [final、static、synchronized] 返回值类型 方法名称(参数类型 参数名称,…..) throws Excption1,Exception2{
   rturn 返回值(没有返回值则表示返回调用处);
}

Object类对线程的支持---等待和唤醒

Object类是所有类的父类，在此类中又一下几个方法是对线程操作有所支持的。

线程的唤醒又两个方法：notify、notifyAll。一般来说，所有等待的线程会按照顺序进行排列，如果现在采用notify()方法，则会唤醒第一个等待的线程执行，而如果使用了notifyAll()方法，则会唤醒所有正在等待状态中得线程，哪个线程的优先级高，则就有可能执行。

线程的生命周期


一个新的线程被创建之后，通过start()方法进入到运行状态，在运行状态中可以使用yield()方法礼让，但是仍然可以进行，如果现在一个线程需要暂停，可是使用suspend()、sleep()、wait()，如果现在线程不需要再执行，则可以通过stop方法结束(如果run方法执行完毕也表示线程的结束)，或者一个新的线程直接调用stop()方法也可以进行结束。

·suspend()方法：暂时挂起线程。

·resume()方法：恢复挂起的线程

·stop()方法：停止线程

因为以上方法会产生死锁的问题，所以很少使用，如果想停止一个线程，则可以使用一下委婉的方式：

class MyThread implements Runnable{
	private boolean flag = true ;	// 定义标志位
	public void run(){
		int i = 0 ;
		while(this.flag){
			System.out.println(Thread.currentThread().getName()
				+"运行，i = " + (i++)) ;
		}
	}
	public void stop(){
		this.flag = false ;	// 修改标志位
	}
};
public class StopDemo{
	public static void main(String args[]){
		MyThread my = new MyThread() ;
		Thread t = new Thread(my,"线程") ;	// 建立线程对象
		t.start() ;	// 启动线程
		try{
			Thread.sleep(30) ;
		}catch(Exception e){
			
		}
		my.stop() ;	// 修改标志位，停止运行
	}
};
cz1029648683
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ROS2多线程 MultiThreadedExecutor
jjjqqq123321的博客
02-29 581
ROS2多线程
多线程简介
Bug_marker的博客
11-29 4664
一、概念 1、并发与并行 并行：多个任务在同一个时刻点同时执行。效率高 并发：多个任务在同一段时间内分时执行。效率低，宏观上同时执行，微观上分时执行。 2、进程与线程 进程：内存中正在运行的应用程序，是系统进行资源分配和调度的基本单位。每一个进程有自己独立的运行空间，相互之间不影响。进程就是程序的一次执行过程，即是一个进程从加载到内存到从内存中释放消亡的过程。 线程：进程内部的独立运行单元，是操作系统能够进行运算调度的最小单位，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序.
Java多线程的知识点
weixin_59796310的博客
05-28 4849
Java多线程的知识点
ROS2机器人编程简述humble-第二章-Executors .3.5
zhangrelay的专栏
01-21 2371
为了不抵消中间件的QoS设置，传入消息不存储在客户端库层的队列中，而是保留在中间件中，直到回调函数处理该消息。显式Executor类（在rclcpp中的Executor.hpp中，在rclpy中的executions.py中，或在rclc中的executer.h中）提供了比ROS1中的自旋机制更多的执行管理控制，尽管基本API非常相似。虽然rclcpp的三个执行器在大多数应用程序中运行良好，但存在一些问题，使它们不适合实时应用程序，因为实时应用程序需要定义良好的执行时间、确定性和对执行顺序的自定义控制。
【2023】java多线程基础篇及常用线程类
weixin_52315708的博客
07-03 182
> 首先，我们需要有一个“线程”类。JDK提供了Thread类和Runnable接口来让我们实现自己的“线程”类。 > > 1. 继承Thread类，并重写run方法； > 2. 实现Runnable接口的run方法；
C#基于委托实现多线程之间操作的方法
01-01
本文实例讲述了C#基于委托实现多线程之间操作的方法。分享给大家供大家参考，具体如下： 有的时候我们要起多个线程，更多的时候可能会有某个线程会去操作其他线程里的属性。 但是线程是并发的，一般的调用是无法实现...
C#实现多线程写入同一个文件的方法
12-31
本文实例讲述了C#实现多线程写入同一个文件的方法。分享给大家供大家参考。具体实现方法如下： namespace WfpApp { public partial class Form2 : Form { object obj = new object(); public Form2() { ...
Python多线程及其基本使用方法实例分析
01-02
本文实例讲述了Python多线程及其基本使用方法。分享给大家供大家参考，具体如下： 学习Python的多线程（Multi-threading），至少应该要有进程与线程的基本概念，可以参考：...
C# 多线程对资源读写时如何控制的方法
01-19
1、多个线程对同一个队列进行读写操作，要注意进行读写控制，某个线程在读取的时候，不允许其它线程读、写；某个线程在写的时候，不允许其它线程进行读写。 2、对字典进行读写时，进行独占式访问定义一个字典，再...
php三种实现多线程类似的方法
12-18
当需要多线程的时候，可以用curl_multi一次性请求多个操作来完成，但curl走的是网络通信，效率与可靠性就比较差了的。 function main(){ $sql = "select waybill_id,order_id from waybill where status>40 order...
C++多线程操作
永不秃头的三三的博客
02-24 413
本文主要介绍了thread创建线程的相关知识点，方便日后自己回顾也希望能够帮助到大家，主要的内容包含了thread创建线程、互斥量mutex、条件变量condition_variable、aysnc创建线程以及原子操作等相关知识
多线程的最全基本操作用法
starry1441的博客
04-30 475
线程 进程是系统分配资源的最小单位，线程是系统调度的最小单位。一个进程内的线程之间是可以共享资源 的
Java--运算符优先级
qq_37676636的博客
11-27 163
java基础（二）——多线程、常用类
波仔头的博客
09-30 354
java基础第十章 多线程（基础）10.1 相关的概念10.2 两种实现多线程的方式10.3 线程的生命周期10.4 Thread的相关API10.5 关键字：volatile10.6 关键字：synchronized（同步）10.7 线程通信第十一章 常用类11.1 包装类11.1.1 包装类11.1.2 装箱与拆箱11.1.3 包装类的一些API11.1.4 包装类对象的缓存问题11.2 字符串11.2.1 字符串的特点11.2.2 字符串对象的比较11.2.3 空字符的比较11.2.4 字符
144.daemon守护线程
qq_43808700的博客
09-30 210
线程分为用户线程 1和守护线程 2，虚拟机不用等待守护线程执行完毕 将普通线程设置成为守护线程 package zy.thread; public class daemonThread { public static void main(String[] args) { god g = new god(); person p = new person(); g.setDaemon(true); //将上帝线程设置成守护线程 g.start(); p.start(); } } c.
多线程常用方法比较汇总
I'm Sure
11-15 100
从操作系统的角度讲，os会维护一个ready queue（就绪的线程队列）。并且在某一时刻cpu只为ready queue中位于队列头部的线程服务。 但是[u]当前正在被服务的线程可能觉得cpu的服务质量不够好，于是提前退出，这就是yield。[/u]（这是yield的使用目的） 或者当前正在被服务的线程需要睡一会，醒来后继续被服务，这就是sleep。 sleep方法不推荐使用，可用wa...
线程常见的几种方法
这个人很懒，什么都没有留下。
11-13 4630
Thread静态方法 1. Thread.sleep(misseconeds) 睡眠：当前线程暂停一段时间让给别的线程去运行。Sleep复活时间，根据你传入的睡眠时间而定，等到睡眠到规定的时间后，线程自动复活，它不会释放锁资源。2. Thread.yield（） 让当前正在执行线程停下来一下，把执行机会让给别的在等待的线程，自己回到等待的就绪队列里面，自己也有可能会运行到，但更大的机会是让别的等待线程运行，相当于将自己的优先级暂时降低一下，把机会让给别人一会儿。 Thread实例方法 1. start
java之yield(),sleep(),wait()区别详解-备忘笔记
攻城师
12-23 3240
1、sleep() 使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。 例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程...
线程的基本知识和使用方法
kelery的博客
05-12 4078
线程 - 基本操作 派生：线程在进程内派生出来，它即可由进程派生，也可由线程派生。 线程的状态与操作图册 阻塞（Block）：如果一个线程在执行过程中需要等待某个事件发生，则被阻塞。 激活（unblock）：如果阻塞线程的事件发生，则该线程被激活并进入就绪队列。 调度（schedule）：选择一个就绪线程进入执行状态。 结束（Finish）：如果一个线程执行结束，它的寄
java多线程并发操作全局变量的方法
最新发布
09-07
3. 利用java.util.concurrent包下的原子类：使用AtomicInteger、AtomicLong等原子类来代替普通的int、long等类型的全局变量，原子类提供了一系列的原子操作方法，保证了对变量的操作是线程安全的。例如： ``` ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值