Java多线程基础

最新推荐文章于 2024-03-10 23:38:03 发布

遇见我是你的荣幸

最新推荐文章于 2024-03-10 23:38:03 发布

阅读量127

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/u010689849/article/details/86664463

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、进程和线程

当一个程序进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。

线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。

二、线程实现的几种方式

1.实现方式一：子类继承Thread

继承Thread类，重写run()方法，调用start()方法执行线程

public class ThreadMain {
	public static void main(String[] args) {
		new Thread() {
			public void run() {
				for (int i = 0; i < 1000; i++) {
					System.out.println(getName()+ "   i为:" + i);
				}
			}
		}.start();
		for (int i = 0; i < 1000; i++) {
			System.out.println(Thread.currentThread().getName() + "  i为:" + i);
		}
	}
}

结果如下：

可以看到代码只显式创建了一个线程，但实际上有两个线程，当Java程序开始运行后程序至少会创建一个主线程，而主线程方法执行不是由run()来确定，而是由main()方法代表主线程的执行体。

2.实现Runnable接口创建线程

Runnable是一个函数式接口，定义Runnable接口实现类，并以此创建对象，将创建的对象作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

public class RunnableMain {
	public static void main(String[] args) {
		//实现Runnable接口的Lambda表达式
		new Thread(() -> {
			for (int i = 0; i < 1000; i++) {
				System.out.println(Thread.currentThread().getName() + "  实现Runnable接口i为:" + i);
			}
		}).start();
		for (int i = 0; i < 1000; i++) {
			System.out.println(Thread.currentThread().getName() + "  i为:" + i);
		}
	}
}

通过Runnable接口来获得线程对象，必须使用Thread.currentThread().getName()

3.使用Callable和Future创建线程

Callable和Runnable一样是一个函数式接口，但Callable的线程执行体是call()方法,区别是Runnable的run()没有返回值，而call有返回值。call（）方法可以声明抛出异常。

实现Callable接口来创建对象后，并不能直接作为Thread的target,因为Thread的target是Runnable对象，而Callable并不是Runnable的子接口。所以需要使用Future来包装Callable对象。

这里使用Future接口的实现类FutureTask来包装Callable。FutureTask实现了Future接口，并实现了Runable接口，可以作为Thread类的target。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableMain {

	public static void main(String[] args) {
		FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)() -> {
			int i = 0;
			for ( i = 0; i < 100; i++) {
				System.out.println(Thread.currentThread().getName() + "  i为:" + i);
			}
			return i;
		});
		new Thread(task).start();
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + "  i为:" + i);
		}
	}
}

3.创建线程的三种方式的优缺点

通过继承Thread和实现Runnable、Callable接口都可以实现多线程。实现Runnable、Callable接口的方式基本一样。

采用实现Runnable、Callable接口优缺点：

实现了Runnable、Callable接口还可以继承其他类，灵活性更高
这种方式多个线程可以共享一个target,如果多个线程处理同一个资源，能更好的实现代码复用，可以将数据，代码分开，形成清晰的模型。
缺点是编码稍微复杂点。

采用继承Thread优缺点

线程类已经继承了Thread，无法再继承其他类
优势是编码简单

三、线程的生命周期

线程的状态包括：新建，就绪，运行，阻塞，死亡。

新建：当程序使用new关键字创建线程后就处于新建状态。

就绪：当线程对象调用start()方法后该线程就处于就绪状态(只有新建状态才能调用start(),否者将出现IllegalThreadStateException异常)。

运行：线程开始执行run()方法后该线程就处于运行状态（如果程序不调用start()方法，而是直接调用run()方法将是单线程执行，如果调用了run()程序就不再是新建状态，如果再次调用start()方法将会报错）

阻塞：线程调用sleep()方法；线程调用了一个阻塞式IO方法；线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有；线程在等待某个通知（notify）；程序调用了线程的suspend()方法将该线程挂起。

死亡：当run()或call()方法执行完，线程死亡。线程抛出未捕获异常。

四、线程池

Executors类提供了4种不同的线程池：newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor

1、newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）

2、newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）

3、newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。

4、newScheduledThreadPool：适用于执行延时或者周期性任务。

主要参数：

corePoolSize：核心池的大小

maximumPoolSize：线程池最大线程数

keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

unit：参数keepAliveTime的时间单位