Java 多线程 01 多线程、线程池

1 多线程

1.1 介绍

进程： 进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程： 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

多线程：一个程序中有多个线程在同时进行。

创建线程的目的：

• 是为了建立程序单独的执行路径，让多部分代码实现同时执行。
• 对于主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。

1.2 程序运行原理

1）分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

2）抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。

其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3 主线程

JVM启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。

1.4 创建线程

1）创建线程方式一：继承Thread类

步骤：

1. 定义一个类继承Thread
2. 重写run()方法
3. 创建子类对象
4. 调用start()方法

// 创建自己的线程类
public class MyThread extends Thread {

	// 定义指定线程名称的构造方法
	public MyThread(String name) {
		// 调用父类的构造方法，指定线程的名称
		super(name);
	}

	// 重写run()方法，完成该线程执行的逻辑
	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			System.out.println(getName() + ": is running..." + i);
		}
	}
}

// 测试类（主线程）
public class TestSth {
	public static void main(String[] args) {
		// 1 创建自定义线程对象
		MyThread mThread = new MyThread("我的线程");
		// 2 开启线程
		mThread.start();
		// 3 在主方法中执行for循环
		for (int i = 0; i < 50; i++) {
			System.out.println("主线程。。。");
		}
	}
}

2）创建线程方式二：实现Runnable接口

步骤：

1. 定义类实现Runnable接口
2. 覆盖接口中的run()方法
3. 创建Thread类的对象
4. 将Runnable接口的子类对象作为参数传递给Thread类的构造函数
5. 调用Thread类的start()方法开启线程

// 定义类实现Runnable接口
public class MyRunnable implements Runnable {

	@Override
	public void run() {

		for (int i = 0; i < 50; i++) {
			System.out.println("我的线程...." + i);
		}
	}
}
// 测试类（主线程）
public class TestSth {
	public static void main(String[] args) {
		// 1 创建线程执行目标类对象
		Runnable runnable = new MyRunnable();
		// 2 将Runnable接口的子类对象作为参数传递给Thread类的构造函数
		Thread t1 = new Thread(runnable);
		Thread t2 = new Thread(runnable);
		// 3 开启线程
		t1.start();
		t2.start();

		// 主线程for循环
		for (int i = 0; i < 50; i++) {
			System.out.println("主线程...." + i);
		}
	}
}

1.5 继承Thread和实现Runnable接口区别

• 实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。
• 创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

1.6 实现Runnable的好处

实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象， 类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

1.7 线程的匿名内部类使用

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

示例：方式一，创建线程对象，直接重写Thread类中的run()方法

public static void main(String[] args) {
	// 创建线程对象，直接重写Thread类中的run()方法
	new Thread() {
		public void run() {
			for (int i = 0; i < 50; i++) {
				System.out.println(Thread.currentThread().getName() + "..." + i);
			}
		}
	}.start();
	// 主线程循环
	for (int i = 0; i < 50; i++) {
		System.out.println("主线程。。。" + i);
	}
}

示例：方式二，实现runnable接口，重写接口中的run()方法

public static void main(String[] args) {

	Runnable runnable=new Runnable() {
		@Override
		public void run() {

			for (int i = 0; i < 50; i++) {
				System.out.println(Thread.currentThread().getName()+"。。。" + i);
			}
		}
	};
	// 启动线程
	new Thread(runnable).start();
	// 主线程
	for (int i = 0; i < 50; i++) {
		System.out.println("主线程。。。" + i);
	}
}

2 线程池

2.1 介绍

线程池， 其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

为什么要使用线程池？

• 创建和销毁线程花费的时间和消耗的资源大。
• 太多的线程会过度消耗内存而导致系统资源不足。

2.2 使用线程池

1）方式一：Runnable接口

步骤：

1. 创建线程池对象
2. 创建Runnable接口子类对象
3. 提交Runnable接口子类对象
4. 关闭线程池

// 创建Runnable接口子类对象
public class MyRunnable implements Runnable {

	@Override
	public void run() {

		System.out.println("我要一个线程。");
		
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("线程来了："+Thread.currentThread().getName());
		System.out.println("用完了线程，你回到池里吧");
	}
}

// 测试类（主线程）
public static void main(String[] args) {

	// 1 创建线程池对象
	ExecutorService service=Executors.newFixedThreadPool(2);// 包含2个线程对象
	// 2 创建Runnable实例对象
	MyRunnable mRunnable=new MyRunnable();
	// 3 从线程池中获取线程对象，然后调用run()方法
	service.submit(mRunnable);
	service.submit(mRunnable);
	service.submit(mRunnable);
	// 4 关闭线程池
	service.shutdown();
}

注意：

• submit()方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中。

2）方式二：Callable接口

步骤：

1. 创建线程池对象
2. 创建Callable接口子类对象
3. 提交Callable接口子类对象
4. 关闭线程池

// 创建Callable接口子类对象
public class MyCallable implements Callable {

	@Override
	public Object call() throws Exception {

		System.out.println("我要一个线程。。。");
		Thread.sleep(2000);
		System.out.println("线程来了。。。" + Thread.currentThread().getName());
		System.out.println("线程用完了，回到池里吧");
		return null;
	}
}

// 测试类（主线程）
public static void main(String[] args) {
	// 1 创建线程池对象
	ExecutorService service=Executors.newFixedThreadPool(2);// 包含2个线程对象
	// 2 创建Callable实例对象
	MyCallable myCallable=new MyCallable();
	// 3 从线程池中获取线程对象，然后调用run()方法
	service.submit(myCallable);
	service.submit(myCallable);
	service.submit(myCallable);
	// 4 关闭线程池
	service.shutdown();
}