java 多线程与并发编程 java多线程并行处理

转载

hochie 2023-07-18 17:23:14

文章标签 java 多线程与并发编程 Java 多线程并行线程池 文章分类 Java 后端开发

引言

多线程使得程序中的多个任务可以同时执行

Java内部支持多线程

线程简介

线程是指一个任务从头至尾的执行流程

Java中，每个任务都实现 Runnable 接口，也称为可雨欣对象

创建任务和线程

一个任务类必须实现 Runnable 接口，任务必须从线程运行。

Runnable 接口只包含一个 run 方法，创建任务类的时候实现它就行了

流程：编写任务类

创建一个任务实例

放到线程中执行

Thread 类

Thread 类包含为任务而创建的线程的构造方法，以及控制线程的方法

void yield() 方法为其他线程临时让出CPU时间

void sleep(long millis) 方法可以将线程设置为休眠以确保其他线程的执行

void join() 方法使一个线程等待另一个线程的结束

void setPriority(int p) 方法设置线程的优先级

下面对上述两个模块举栗子：

实现任务类的两种方法：继承 Thread 类，实现 Runnable 接口 (推荐后者)

先采用继承 Thread 的方法

class NewThread extends Thread {
	char c;

	public NewThread(char cc) {
		c = cc;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10; i++)
			System.out.print(c + " ");
	}
}

class test {
	public static void main(String[] args) {
		NewThread nt1 = new NewThread('A');
		NewThread nt2 = new NewThread('B');
		nt1.start();
		nt2.start();
		new NewThread('C').start();
	}
}
// 结果是
// A B B B C B A B B B B B B A C A C A C C C A A A A A C C C C

再采用实现 Runnable 接口的方法

class NewRun implements Runnable {
	char c;

	public NewRun(char cc) {
		c = cc;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10; i++)
			System.out.print(c + " ");
	}
}

class test {
	public static void main(String[] args) {
		NewRun nr1 = new NewRun('A');
		Runnable nr2 = new NewRun('B');
		new Thread(nr1).start();
		new Thread(nr2).start();
		new Thread(new NewRun('C')).start(); // 推荐这种写法
	}
}
// 结果是
// A C B B B B B B C C C C C C C C C B B B B A A A A A A A A A

线程池

如果有大量并行任务，一个一个地开始可能会限制吞吐量造成性能降低。Java提供线程池的实现。

Executor 接口：执行线程池中的任务

ExecutorService 接口：管理和控制任务，是 Executor 的子接口

为了创建一个 Executor 对象，可以使用 Executors 类中的静态方法，比如： newFixedThreadpool(int) 方法在池中创建固定数目的线程，newCachedThreadPool() 方法会创建一个新线程，举例子看吧

将上面程序改写

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class NewRun implements Runnable {
	char c;

	public NewRun(char cc) {
		c = cc;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10; i++)
			System.out.print(c + " ");
	}
}

class test {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newFixedThreadPool(3);
		executor.execute(new NewRun('A'));
		executor.execute(new NewRun('B'));
		executor.execute(new NewRun('C'));
		executor.shutdown(); // 关闭之后不接受新任务，但是将继续执行完现有任务
	}
}
// 结果是
// A C A B C C A B B C A A A C B C C C C C A A A A B B B B B B

如果用下面语句替换第20行

ExecutorService executor = Executors.newFixedThreadPool(1);

这三个任务将顺次执行，因为在线程池中只有一个线程。

如果换成 ExecutorService executor = Executors.newCachedThreadPool();

所有任务都并发执行，因为将为每个等待的任务创建一个新线程。