Java多线程并发

最新推荐文章于 2024-07-27 15:32:30 发布

ZangChen.

最新推荐文章于 2024-07-27 15:32:30 发布

阅读量85

点赞数

分类专栏： java 文章标签：多线程

本文链接：https://blog.csdn.net/weixin_45473834/article/details/111144170

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

java多线程并发

4.1.1. JAVA并发知识库

java线程实现和创建方式

4.1.2.1. 继承Thread类

Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程唯一方法就是通过Thread类的start（）实例方法。start（）方法是一个和native方法，他将启动一个和新线程，并执行run（）方法。

public class MyThread extends Thread { 
public void run() { 
System.out.println("MyThread.run()"); 
} 
} 
MyThread myThread1 = new MyThread(); 
myThread1.start();

4.1.2.2. 实现Runnable接口。

如果自己的类已经extends另一个类，就无法直接extends Thread，此时可以实现一个Runnable接口

public class MyThread extends OtherClass implements Runnable{
	public void run(){
		system.out.println("MyThread.run()");
	}
}

//启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例： 
MyThread myThread = new MyThread(); 
Thread thread = new Thread(myThread); 
thread.start(); 
//事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run() 
public void run() { 
	if (target != null) { 
	target.run(); 
	} 
}

4.1.2.3. ExecutorService、Callable、Future有返回值线程

有返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。

//创建一个线程池 
ExecutorService pool = Executors.newFixedThreadPool(taskSize); 
// 创建多个有返回值的任务
 List<Future> list = new ArrayList<Future>();
  for (int i = 0; i < taskSize; i++) { 
  Callable c = new MyCallable(i + " "); 
 // 执行任务并获取Future对象 
 Future f = pool.submit(c); 
 list.add(f); 
 } 
 // 关闭线程池 
 pool.shutdown(); 
 // 获取所有并发任务的运行结果 
 for (Future f : list) { 
 // 从Future对象上获取任务的返回值，并输出到控制台 
 System.out.println("res：" + f.get().toString()); }

4.1.2.4. 基于线程池的方式

线程和数据库连接这些资源都是非常宝贵的资源，那么每次需要的时候创建，不需要的时候销毁，是非常浪费的。那么我们就可以使用缓存策略，也就是线程池。

// 创建线程池 
ExecutorService threadPool = Executors.newFixedThreadPool(10); 
while(true) { 
	threadPool.execute(new Runnable() { // 提交多个线程任务，并执行 
	@Override 
	public void run() { System.out.println(Thread.currentThread().getName() + " is running .."); 
	try { 
		Thread.sleep(3000); 
	} catch (InterruptedException e) {
 		e.printStackTrace(); 
 	} 
   } 
  }); 
 } 
 }

4.1.3. 4种线程池

java里面线程池的顶级借口是Exector，但是严格意义上将Executor并不是一个线程池，而是一个执行线程的工具。真正的线程池接口是ExecutorService.

在这里插入图片描述

4.1.3.1. newCachedThreadPool

创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用他们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序的性能，调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。

4.1.3.2. newFixedThreadPool

创建一个可重用固定线程数的线程池，已共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

4.1.3.3. newScheduledThreadPool

创建一个线程池，他可安排在给定延迟后运行命令或者定期的执行。

ScheduledExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(3); 
scheduledThreadPool.schedule(newRunnable(){ 
		@Override public void run() {
 			System.out.println("延迟三秒"); 
 									} 
 	}, 3, TimeUnit.SECONDS); 
 scheduledThreadPool.scheduleAtFixedRate(newRunnable(){ 
	 @Override 
 	public void run() {
  		System.out.println("延迟1秒后每三秒执行一次"); 
  					  } 
  },1,3,TimeUnit.SECONDS);

4.1.3.4. newSingleThreadExecutor

Executors.newSingleThreadExecutor()返回一个线程池（这个线程池只有一个线程），这个线程可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去！

4.1.4. 线程生命周期(状态)

当线程被创建并启动以后，他既不是已启动就进入了执行状态，也不是一直处于执行状态。
在线程的生命周期中，他要经过新建线程（New）、就绪（Runnable）、运行（Running）
、阻塞（rlocked）和死亡（Dead）五种状态。尤其是当线程启动以后，他不可能一直“霸占”着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换。

4.1.4.1 新建状态（NEW）

当程序使用new 关键字创建了一个线程之后，该线程就处于新建状态，此时仅有JVM为其分配内存，并初始化器成员变量的值

4.1.4.2 就绪状态（RUNNABLE）

单线程对象调用了start（）方法之后，该线程处于就绪状态，java虚拟机就会为其创建方法调用栈和程序计数器，等地啊调度运行。

4.1.4.3 运行状态（RUNNING）

如果处于就绪状态的线程获得了CPU，开始执行run（）方法的线程执行体，则该西安城处于运行状态。

4.1.4.4 阻塞状态（BLOCKED）

阻塞状态是指线程因为某种原因放弃了cpu的使用权，也即让出了cpu timeslice, 暂时停止运行。
直到线程进入可运行（runnable）状态，才有机会再次获得cpu timeslice 转到运行（running）状态。阻塞的情况分三种：

	等待阻塞（o.wait->等待队列）：
		运行（running）的线程执行o.wait（）方法，JVM会把线程放入等待队列（waitting queue）中。

    同步阻塞(lock->锁池)
   		运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁			
   	池(lock pool)中。

	其他阻塞(sleep/join)
		运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线
	程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新
	转入可运行(runnable)状态。

4.1.4.5 线程死亡（DEAD）

线程会在下面三种方式结束，结束后就是死亡状态。

正常结束
1.run（）或call（）方法执行完成，线程正常结束。

异常结束
2.线程抛出一个未捕获的Exception或Error.

调用stop
3.直接调用该线程的stop（）方法来结束该线程–该方法容易导致死锁，不推荐使用。

在这里插入图片描述

4.1.5终止线程的4种方式

4.1.5.1正常结束运行

	程序运行结束，线程自动结束。

4.1.5.2 使用推出标志退出线程

一般run()方法执行完，线程就会正常结束，然而，常常有些线程是伺服线程。它们需要长时间的运行，只有在外部某些条件满足的情况下，才能关闭这些线程。使用一个变量来控制循环，例如：最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出，代码示例：

public class ThreadSafe extends Thread { 
public volatile boolean exit = false; 
public void run() { 
	while (!exit){ //do something 
	} 
  } 
}

定义了一个退出标志exit，当exit为true时，while循环退出，exit的默认值为false.在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值。

4.1.5.3. Interrupt方法结束线程

使用interrupt()方法来中断线程有两种情况：

线程处于阻塞状态：如使用了sleep,同步锁的wait,socket中的receiver,accept等方法时，会使线程处于阻塞状态。当调用线程的interrupt()方法时，会抛出InterruptException异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后break跳出循环状态，从而让我们有机会结束这个线程的执行。通常很多人认为只要调用interrupt方法线程就会结束，实际上是错的，一定要先捕获InterruptedException异常之后通过break来跳出循环，才能正常结束run方法。
线程未处于阻塞状态：使用isInterrupted()判断线程的中断标志来退出循环。当使用interrupt()方法时，中断标志就会置true，和使用自定义的标志来控制循环是一样的道理。

public class ThreadSafe extends Thread {
public void run() {
while (!isInterrupted()){ //非阻塞过程中通过判断中断标志来退出
try{
Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出
}catch(InterruptedException e){
e.printStackTrace();
break;//捕获到异常之后，执行break跳出循环
}
}
}
}

4.1.5.4. stop方法终止线程（线程不安全）

	程序中可以直接使用thread.stop()来强行终止线程，但是stop方法是很危险的，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果，不安全主要是：thread.stop()调用之后，创建子线程的线程就会抛出ThreadDeatherror的错误，并且会释放子线程所持有的所有锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用thread.stop()后导致了该线程所持有的所有锁的突然释放(不可控制)，那么被保护数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。因此，并不推荐使用stop方法来终止线程。

4.1.6. sleep与wait 区别

对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。
sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
在调用sleep()方法的过程中，线程不会释放对象锁。
而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

4.1.7. start与run区别

start（）方法来启动线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码。
通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
方法run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了运行状态，开始运行run函数当中的代码。 Run方法运行结束，此线程终止。然后CPU再调度其它线程。

4.1.8. JAVA后台线程

定义：守护线程–也称“服务线程”，他是后台线程，它有一个特性，即为用户线程提供公共服务，在没有用户线程可服务时会自动离开。
优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。
设置：通过setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护线程的方式是在线程对象创建之前用线程对象的setDaemon方法。
在Daemon线程中产生的新线程也是Daemon的。
线程则是JVM级别的，以Tomcat 为例，如果你在Web 应用中启动一个线程，这个线程的生命周期并不会和Web应用程序保持同步。也就是说，即使你停止了Web应用，这个线程依旧是活跃的。
example: 垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的Thread,程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是JVM上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。
生命周期：守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。也就是说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则JVM不会退出。