Java多线程和并行程序设计

左手的ㄟ右手 2022-05-18 00:14 167阅读 0赞

## 引言 ##

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

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();

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

## 线程同步 ##

线程同步用于协调相互依赖的线程的执行，如果一个共享资源被多个线程同时访问，可能会遭到破坏

不同任务以冲突的方式访问一个公共资源，称为 竞争状态。

如果没有竞争状态，则称该线程是安全的。

为了避免竞争状态，可以设置 临界区，使用关键字 synchronized 来同步。

可以在方法中添加 synchronized，比如 synchronized void count(int i)\{\}

也可以对任何对象加锁：