回顾多线程基础

最新推荐文章于 2024-08-26 16:40:46 发布
最新推荐文章于 2024-08-26 16:40:46 发布
阅读量91 收藏 1
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45979629/article/details/111148792
版权

首先我们要明白什么是进程，什么是线程？

进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。（进程是资源分配的最小单位）

线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）

什么是多线程？

  • 1.多进程是指操作系统能同时运行多个任务（程序）。
  • 2.多线程是指在同一程序中有多个顺序流在执行.
  • 3.很多线程都是模拟出来的，真正的多线程指的是多个cpu,即多核，如服务器。
  • 4.如果是模拟出来的多线程，即在同一个cpu的情况下，cpu只能执行一个程序或一行代码，因为切换的很快，所以有了同时执行的错觉。
  • 5.在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

线程的生命周期为什么？
线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。

我们之前在多线程之前学习的多线程基础基本上都是单线程执行的

普通方法调用和多线程

在这里插入图片描述

多线程核心概念

在这里插入图片描述

实现多线程的几种方式：

  • 继承Thread类:

首先，我们看JDK1.8的帮助文档对Thread类的描述:空线是一个线程在执行一个程序。java虚拟机的应用程序可以有多个同时执行的线程。 每一个线程都有一个优先权。具有更高优先级的线程在优先于较低优先级的线程中执行。每一个线程可能会或可能不会被标记为一个守护进程。在一些线程中运行的代码创建了一个新的Thread对象时，新线程的优先级被设置为等于创建线程的优先级，是守护线程的当且仅当创建线程是一个守护进程。

让我们来写一个例子：

public class TestThread extends Thread{
	
private String url;//文件地址
private String fileName;//文件名
	
	
	public TestThread(String url, String fileName) {
	this.url = url;
	this.fileName = fileName;
}


	@Override
	public void run() {
	WebDownLoader webDownLoader = new WebDownLoader();
	webDownLoader.DownloadPicture(url, fileName);
	System.out.println("下载了文件:"+fileName);	
	}
	
	public static void main(String[] args) {
		TestThread testThread = new TestThread("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1606911965336&di=b68b28cd8bd82094ddfd3f9ecfd380e4&imgtype=0&src=http%3A%2F%2Fimage.namedq.com%2Fuploads%2F20181006%2F19%2F1538823821-QrIiEnXmAv.jpg", "亚索");
		TestThread testThread2 = new TestThread("https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2106604486,285772919&fm=26&gp=0.jpg", "光辉");
	   testThread.start();
	   testThread2.start();
	}
	
}

//创建一个下载文件的类
 class WebDownLoader{
 //创建一个下载文件的方法
public static void DownloadPicture(String url,String fileName) {
	try {
		FileUtils.copyURLToFile(new URL(url), new File(fileName));
	} catch (MalformedURLException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	
}
}

运行后：发现在项目中会多出两个下载的文件。

序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用MitiSay的两个对象的start方法，另外两个线程也启动了，这样，两条线程理论上就同时去下载两个文件。

注意：start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。
从程序运行的结果可以发现，多线程程序是乱序执行。因此，只有乱序执行的代码才有必要设计为多线程。
Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留出一定时间给其他线程执行的机会。
实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。

  • 实现Runnable接口

首先，让我们看看JDK1.8帮助文档对Runnable接口的描述：创建一个线程是声明一个类实现Runnable接口的其他方式。该类实现run方法。那类的一个实例可以分配，作为一个参数传递Thread时创建，并开始。此外，Runnable一类是主动的而不是子类Thread提供手段。一个类实现Runnable可以运行没有子Thread实例化一个Thread实例并将自身作为目标。在大多数情况下，这Runnable接口应该是如果你只打算重写run()方法并没有其他Thread方法。这是重要的因为方法重写，继承类不应该继承除非程序员打算修改或增强类的基本行为。

让我们来写一个例子：

/**
 *  演示线程的停止:1.创建线程，然后一直让它运行，通过我们自定义的方法让线程停止
 *  2.不建议使用JDK中的自带的API方法来让线程停止，因为可能会存在某些问题（官方推荐我们使用:自定义一个标志位来让某个线程进行停止）
 * 
 *
 */
public class TestThreadStop implements  Runnable{

	private static boolean flag=true;
	
	
	@Override
	public void run() {
	while (flag) {
		System.out.println(Thread.currentThread().getName()+"-->循环");
	}	
	}
	void testflag(){
		flag=false;
		System.out.println("自定义线程停止");
	}
	
 

public static void main(String[] args) {
	TestThreadStop testThreadStop = new TestThreadStop();	
	  new Thread(testThreadStop).start();
	
	  //主线程执行for循环
	  for (int i = 0; i < 1000; i++) {
		if (i==900) {
			//让我们自定义的线程停止
			testThreadStop.testflag();
		}
		System.out.println("主线程执行--》"+i);
	}
	}
}

输出结果:
在这里插入图片描述
当自定义线程输出到达900时候，线程会根据标志位停止，线程执行完毕。主线程继续执行。

  • 实现Callable接口

首先，让我们看看JDK1.8帮助文档对Callable接口的描述:返回结果的一个任务，并可能抛出异常。用户定义一个不带参数调用 call 的Callable接口类似于Runnable，，是专为其实例的类可能被另一个线程执行。然而，Runnable，不返回结果并不能抛出异常。
Executors类包含的实用方法与其他常见的形式转换为Callable类。

让我们来写一个例子：

public class TestCallable  implements Callable<Boolean>{

	@Override
	public Boolean call() throws Exception {
		System.out.println("继承Callable接口的线程"+Thread.currentThread().getName()+"执行");
		return true;
	}
	
	public static void main(String[] args) {
		//1.创建两个继承了Callable接口的类的线程对象
	   TestCallable testCallable = new TestCallable();
	TestCallable testCallable1 = new TestCallable();
	    //2.创建线程池服务，线程池最大为2个线程
	ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
	//3.往线程池中提交线程,并获取到线程执行call方法结果
	Future<Boolean> submit = newCachedThreadPool.submit(testCallable);
	Future<Boolean> submit2 = newCachedThreadPool.submit(testCallable1);
	//4.获取接口
	try {
		Boolean boolean1 = submit.get();
		
		
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (ExecutionException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	try {
		Boolean boolean2 = submit2.get();
		
		
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (ExecutionException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	}
	

}

输出结果:
在这里插入图片描述

那我们之前学习了继承Thread类和实现Runnable接口来创建线程，这两个方式的区别是什么？

  • 如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。所以Runnbale比Thread跟具有优势
  • 可以避免java中的单继承的限制
  • 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
  • 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

线程状态转换（线程的生命周期）

在这里插入图片描述
1、新建状态（New）：新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
（二）同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

线程的调度

  1. 线程睡眠：Thread.sleep(long millis)方法
    在这里插入图片描述

让我们来写一个例子:

public class TestThreadSleep {

	
	private static int mun=10;
	//模拟倒计时方法
	public static void tenDown() throws InterruptedException{
		while (mun>0) {
			Thread.sleep(2000);
			System.out.println(mun--);
		}	
	}
	
	//打印当前时间方法
	private static void datedayin(){
		while (true) {
			Date date = new Date(System.currentTimeMillis());//获取当前时间
			try {
				Thread.sleep(1000);//睡眠一秒
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			System.out.println("当前时间是:"+new SimpleDateFormat("HH:mm:ss").format(date));
			 date = new Date(System.currentTimeMillis());//更新当前时间
			
		}
	}
	
	
	
	
	public static void main(String[] args) {
		
		//模拟倒计时
		/*try {
			tenDown();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}*/
		
		//打印当前时间
		datedayin();
		
	
		
		
		
	}
}

输出结果：
在这里插入图片描述

注意:wait和sleep的区别:Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){…}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

2.线程礼让：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。
在这里插入图片描述
3.线程强制执行：join()方法,等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

让我们写一个例子：

/**
 * 
 * 演示java线程中的join方法:使某个线程进行插队，直到这个线程执行完后，其他线程才能执行
 *
 */
public class TestJoin implements Runnable{

	@Override
	public void run() {
	for (int i = 0; i < 200; i++) {
		System.out.println("大哥线程来执行了:"+Thread.currentThread().getName()+"-->"+i);
	}
		
	}
	
	
	public static void main(String[] args) {
		
//创建自定义线程
		TestJoin testJoin = new TestJoin();
		Thread thread = new Thread(testJoin);
		thread.start();
		
		//主线程执行for循环，到200的时候 join方法让自定义线程进行插队，直到自定义线程执行完后，主线程才继续执行
		//(如果电脑是多核的，有多个cpu,可能在200之前，两个线程会交替执行)
		
		for (int i = 0; i < 500; i++) {
			if (i==200) {
			try {
				thread.join(); //进行插队
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			}
			System.out.println("执行main方法:-->"+i);
			
		}
	}


}

输出结果：
在这里插入图片描述
当主线程达到200的时候，自定义线程使用join方法进行插队，直到自定义线程执行完毕为止，主线程才继续执行。

3.调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。
在这里插入图片描述

注意：每个线程都有默认的优先级。主线程的默认优先级Thread.NORM_PRIORITY。
线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。
JVM提供了10个线程优先级，但与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操作系统中，应该仅仅使用Thread类有以下三个静态常量作为优先级，这样能保证同样的优先级采用了同样的调度方式。

让我们来写一个例子：

/**
 * 
 * 多线程的优先等级：1-10
 * 1 最低
 * 5  默认
 * 10  最高
 */
public class 多线程的优先级 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//获取多线程的优先级等级
		//1.最高优先级
		System.out.println(Thread.MAX_PRIORITY);//10
		//2.默认优先级
		System.out.println(Thread.NORM_PRIORITY);//5
		//3.最低优先级
		System.out.println(Thread.MIN_PRIORITY);//1
		
		Thread t1=new projuct();//获取线程
		Thread t2=new projuct();
		t1.setName("T1");//修改线程名
		t2.setName("T2");
		//查看线程优先级,自定义的线程没有设置前都是默认的优先级 5
		System.out.println(t1.getPriority());//5
		System.out.println(t2.getPriority());//5
		//设置优先级
		t1.setPriority(4);
		t2.setPriority(10);
		//执行线程
		t1.start();
		t2.start();
		
	}

}
//定义一个线程
class projuct extends Thread{
	public void run(){
		for(int i=0;i<30;i++){
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			//获取当前的线程和名称
		}
	}
}

输出结果为：
在这里插入图片描述

 会发现在抢夺CPU调度的过程中，T2线程因为优先级的原因抢夺的CPU时间片会多一些。

守护线程

在这里插入图片描述
让我们来写一个例子:

public class 学习守护线程 {
/**
 * 守护线程
 * 其他所有线程结束，则守护线程退出
 * 守护线程一般都是无限执行的
 * 
 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
Thread t1=new  guard();
t1.setName("t1");
t1.setDaemon(true);//设置t1为守护线程
//知道主线程结束 它才会结束
t1.start();

for(int i=0;i<10;i++){
	System.out.println(Thread.currentThread().getName()+"-->"+i);
	try {
		Thread.sleep(1000);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
	}

}
class guard extends Thread{
	public void run(){
		int i=0;
		while(true){
			i++;
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

输出结果：
在这里插入图片描述

线程的同步

 首先，我们需要理解一个概念：什么是线程的同步？线程的同步就是多个线程同时操作同一个资源。

首先，我们可以看一个多个线程同时操作一个共有资源的例子，会发现出现很多bug和漏洞:

public class TestTicket implements Runnable{

	//总共有10张票
  private int Ticket=10;
	
	@Override
	public void run() {
		
		while (true) {
			if (Ticket<=0) {
				break;//当票被抢完的时候，就退出循环
			}	
			
				try {
					Thread.sleep(100);//每当一个线程抢完一次票的时候，就让线程暂停0.2秒
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				//Thread.currentThread():返回当前线程
				System.out.println(Thread.currentThread().getName()+"抢到了第"+Ticket--+"票");//每当一个线程抢到一张票的时候，票数资源就--	
			
		}
	}
	public static void main(String[] args) {
		//创建线程
		TestTicket testTicket = new TestTicket();
		
		new Thread(testTicket,"小明").start();
		new Thread(testTicket,"老师").start();
		new Thread(testTicket,"黄牛党").start();
	}	

}

结束输出：
在这里插入图片描述
这肯定是不允许的，事实上是不允许几个同时抢到同一张票的，这时候出现了数据混乱。

这时候我们就可以使用synchronized关键字

我们在上面的例子中加入synchronized锁：

public class TestTicket implements Runnable{

	//总共有10张票
  private int Ticket=10;
	
	@Override
	public void run() {
		synchronized (this) {
		while (true) {
			if (Ticket<=0) {
				break;//当票被抢完的时候，就退出循环
			}	
			
				try {
					Thread.sleep(100);//每当一个线程抢完一次票的时候，就让线程暂停0.2秒
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				//Thread.currentThread():返回当前线程
				System.out.println(Thread.currentThread().getName()+"抢到了第"+Ticket--+"票");//每当一个线程抢到一张票的时候，票数资源就--	
			
		}
		}
	}
	public static void main(String[] args) {
		//创建线程
		TestTicket testTicket = new TestTicket();
		
		new Thread(testTicket,"小明").start();
		new Thread(testTicket,"老师").start();
		new Thread(testTicket,"黄牛党").start();
	}	

}

synchronized关键字有什么用？

1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
3) 除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/区块/}，它的作用域是当前对象；
4) synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

什么是死锁？

在这里插入图片描述
简单来说：就是两个线程各有一把锁，但是又想要对面手中的锁，但是又不肯把自己的锁给对方，这时候程序就无法继续向下执行。

/**
 * 演示死锁的概念:当我们去获取到一个对象的锁之后，在这个锁还没有执行完毕的时候去获取到另一个对象的锁（关键是另一个对象的锁还在别的线程的手中）
 * 这就会造成死锁，程序无法向下执行。
 * 或者说:当我们去获取到一个对象的锁之后，在这个锁还没有执行完毕的时候去获取到另一个对象的锁（关键是另一个对象的锁还在别的线程的手中,并且别的线程这时候也想
 * 获取到我们手中对象的锁，这样就会僵持不下，程序无法向下执行，直接卡死）
 * 
 *
 */
/**
 * 演示:1.创建两个小孩对象，小孩1获取到玩具车对象的锁，这时候想去获取到小孩2手中玩具飞机对象的锁
 *     2.小孩2获取到玩具飞机对象的锁，这时候象去获取到小孩1手中玩具车对象的锁
 *     3.这就造成了死锁状态，程序无法向下执行了
 */

//创建玩具车类
class Car{
	
}
//创建玩具飞机类
class Aircraft{
	
}

public class TestDieLock extends Thread {

static	Car car=new Car();
static Aircraft aircraft=new Aircraft();
	

private String child;//小孩名
	


	public TestDieLock(String child) {

	this.child = child;
}

	public void run() {
		try {
			wanju();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

 public void wanju() throws InterruptedException {
	 if (child.equals("小孩1")) {
		synchronized (car) {
			System.out.println("小孩1获取到了玩具车的对象锁");
			Thread.sleep(1000);
			synchronized (aircraft) {
				System.out.println("小孩1还想获取玩具飞机的对象锁");
			}
		}
	}else {
	synchronized (aircraft) {
		System.out.println("小孩2获取到了玩具飞机的对象锁");
		Thread.sleep(1000);
		synchronized (car) {
			System.out.println("小孩2还想获取玩具车的对象锁");
		}
	}
	}
	
}
 
 public static void main(String[] args) {
	TestDieLock testDieLock = new TestDieLock("小孩1");
	TestDieLock testDieLock2 = new TestDieLock("小孩2");
	testDieLock.start();
	testDieLock.start();
}
}

Lock锁

在这里插入图片描述
让我们来写一个例子：

/**
 * 在JDK5.0的时候推出了一个可重入锁：Lock,这个锁可以作用和对象锁相同，但是这个锁需要自己去加锁和解锁，通常我们使用try catch来让我们的方法或者代码块
 * 进行锁机制
 *
 */
public class TestLock implements Runnable{
int num=10;

//定义可重入锁对象
private static  ReentrantLock reentrantlock=new ReentrantLock();

	@Override
	public void run() {
		while (true) {
	try {
		//调用可重入锁对象加锁方法，给下面代码块加锁
		reentrantlock.lock();
		if (num>10) {
			System.out.println(num--);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}	
		}else {
		break;
		}
		
	}finally {
		//使用可重入锁，别忘记在finally中解锁
		reentrantlock.unlock();
	}
		}
	}
	
	public static void main(String[] args) {
		TestLock testLock = new TestLock();
		new Thread(testLock).start();
		new Thread(testLock).start();
		new Thread(testLock).start();
	}
	

}
杨某人的快乐学习日记
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
并发编程系列之线程基础知识回顾
Nicky's blog
08-27 1481
并发编程系列之线程基础知识回顾，并发多线程的知识是很重要而且比较杂的知识点，所以需要花不少时间用于整理。问题1、使用多线程的目的是什么？充分利用cpu资源，可以并发的处理任务
Java多线程基础
♾️
12-07 2186
多线程基础 回顾 1 File类：表示一个文件或文件夹 表示文件: 创建 createNewFile(); 删除 delete(); deleteOnExit(); 存在性判断 exists(); canExecute() canRead() canWrite() getAbsoluatePath(); getParent(); getName(); ...
多线程基础
m0_50507927的博客
05-12 3550
多线程
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 22万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
线程的基础回顾
weixin_48013460的博客
12-31 985
1.死锁/活锁(线程没有出现阻塞，一直处于等待的状态) 死锁：一组互相竞争的资源的线程之间互相等待，导致永久阻塞现象。 活锁：线程没有出现阻塞，一直处于等待的状态. 2.死锁满足的条件 这四个条件同时满足，就会产生死锁。 互斥，共享资源X和Y只能被一个线程占用。 占有且等待，线程T1已经取得共享资源X，在等待共享资源Y的时候，不释放共享资源X 不可抢占，其他线程不能强行抢占线程T1占有的资源。 循环等待，线程T1等待线程T2占有的资源，线程T2等待线程T1占有的资源，就是循环等待。、 死
多线程入门
qq_39093474的博客
12-30 1423
首先我们来看一下进程的概念：看到这里大家可能都不太理解，其实我也不太清楚，不过看了宜春大佬的博客，有了小小的收获。就跟我们玩游戏差不多，点击游戏，游戏会把加载到内存中运行，系统为给他分配资源（这就是大家玩游戏卡的原因，内存只有1g，给他分了0.99g，不卡才怪。）此时进程内存的程序都可以叫做进程，退出游戏，就是进程从内存中销毁了。这里借用一下宜春大佬的图 多线程就是多个线程同时运行或者交替运行，以前电脑只有一个cpu，多线程运行都是交替运行（并发），现在都是4核8核的，可以同时运行8个线程，做到真正的并行
并发编程(一)多线程基础和原理
leon
07-19 4228
多线程基础 最近，准备回顾下多线程相关的知识体系，顺便在这里做个记录。 并发的发展历史 最早的计算机只能解决简单的数学运算问题，比如正弦、 余弦等。运行方式：程序员首先把程序写到纸上，然后穿 孔成卡片，再把卡片盒带入到专门的输入室。输入室会有 专门的操作员将卡片的程序输入到计算机上。计算机运行 完当前的任务以后，把计算结果从打印机上进行输出，操 作员再把打印出来的结果送入到输出室，程序员就可以从 输出室取到结果。然后，操作员再继续从已经送入到输入 室的卡片盒中读入另一个任务重复上述的步骤。 操作员在机
多线程基础一
神韵
08-22 712
目录 一、概念（掌握） 二、多线程并行和并发的区别（掌握） 三、Java程序运行原理和JVM的启动是多线程的吗（掌握） 四、多线程程序实现的方式（掌握） 五、匿名内部类实现线程的两种方式（掌握） 六、获取线程名字和设置名字 七、休眠线程（掌握） 八、守护线程 九、加入线程 十、礼让线程 十一、线程的优先级 十二、同步代码块（掌握） 十三、同步方法（掌握） 十四、线程安全...
多线程线程数设置多少合适
北巷东东的专栏
06-30 2万+
前沿 大家都用过线程池，但是线程池数量设置为多少比较合理呢？ 线程数的设置的最主要的目的是为了充分并合理地使用 CPU 和内存等资源，从而最大限度地提高程序的性能，因此让我们一起去探索吧！ 首先要考虑到 CPU 核心数，那么在 Java 中如何获取核心线程数？ 可以使用 Runtime.getRuntime().availableProcessor() 方法来获取（可能不准确，作为参考） 或者直接去服务器查看 温故为什么使用线程 场景 如果有两个任务需要处理，一个任务A，一个任务B 方案一：一个线程执行任务
Python多线程详解
chuangshangbeidong的博客
11-12 2033
Python多线程详解1 前言1.1 并发与并行1.2 进程、线程、协程2 线程介绍2.1 什么是线程2.2 为什么使用多线程2.3 进程与线程之间的区别3 线程实现3.1 普通创建方式3.2 自定义线程类3.3 守护线程3.4 主线程等待子线程结束4 GIL（Global Interpreter Lock）全局解释器锁参考 1 前言 本系列打算将 Python 中的线程、进程以及协程做一个全面的总结，本文目前是第一部分——多线程。在正式进入线程的讲解之前，我们先来熟悉一下相关的概念。 1.1 并发与并行
python回调函数中使用多线程的方法
09-20
#### 一、理解回调函数与多线程的基础概念 在Python中，回调函数是一种将函数作为参数传递给另一个函数的方式，并在这个被调用的函数内部执行该参数函数。这种方式使得我们可以更加灵活地控制程序流程，特别是在...
python 多线程串行和并行的实例
09-19
#### 一、多线程基础 在讨论具体代码之前，我们先回顾一下多线程的基本概念。 ##### 1.1 什么是多线程？ 多线程是指在一个进程中同时运行多个线程来执行不同的任务。每个线程都是进程的一个执行单元，它们共享...
qt3.rar_Linux QT_qt3 多线程_qt多线程
09-24
Qt3为多线程编程提供了丰富的API，如QThread类，它是Qt中处理线程的基础。QThread允许你在Qt事件循环内创建和管理线程，这样就可以利用Qt的信号和槽机制进行线程间的通信。通过连接信号到槽，可以在不同的线程之间...
浅谈Android中多线程切换的几种方法
01-21
我们先回顾一下Java多线程的几个基础内容，然后再分析总结一些经典代码中对于线程切换的实现方式。 几点基础 多线程切换，大概可以切分为这样几个内容：如何开启多个线程，如何定义每个线程的任务，如何在线程之间...
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 1004
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
最新发布
qq_3512323979的博客
08-26 1007
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 1419
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1960
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 1757
linux上datax 安装以及使用
Java多线程详解：从基础到高级特性
Java多线程合集是一份详尽的教程，涵盖了Java多线程编程的基础到高级概念和实践技巧。以下是对部分章节的详细解读： 1. **Java线程：概念与原理** - 本节介绍了Java中的线程概念，包括线程在操作系统中的地位（相...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杨某人的快乐学习日记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值