个人学习笔记

参考作者

# 如何创建线程？

# 1. 继承 Thread，并且重写父类的 run 方法；

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

	public class MyThread extends Thread {

	@Override
	public void run() {
	System.out.println(Thread.currentThread().getName()); // 线程 1
	}

	public static void main(String[] args) {
	MyThread myThread = new MyThread();
	myThread.setName("线程1");
	myThread.start();
	}

	}

用匿名内部类表示：

	public class MyThread {

	public static void main(String[] args) {
	// 匿名内部类
	Thread thread = new Thread(new Runnable() {
	@Override
	public void run() {
	System.out.println(Thread.currentThread().getName());
	}
	});
	thread.setName("线程2");
	thread.start();
	}
	}

同时匿名内部类可以用 [Lambda].{blue} 表达式来表示：

主要的线程逻辑放在 lambda 方法体内

	public class LambdaTest06 {
	public static void main(String[] args) {
	new Thread(() -> {
	System.out.println("匿名内部类");
	}).start();
	}
	}

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

	public class MyThread extends OtherClass implements Runnable {
	@Override
	public void run(){
	System.out.println("MyThead.run()");
	}
	}
	// 启动 MyThread, 先实例化一个 Thead, 并传入自己的 MyThread 实例
	MyThread myThread = new MyThread();
	Thread thread = new Thread(myThread);
	thread.start();

第二种更常用，从继承上去看，单继承具有局限性

	package com.thread;

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


	public class CallableThreadTest implements Callable<Integer>
	{

	public static void main(String[] args){
	CallableThreadTest ctt = new CallableThreadTest();
	// （2）创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call () 方法的返回值。
	FutureTask<Integer> ft = new FutureTask<>(ctt);
	// （3）使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
	for(int i = 0;i < 100;i++){
	System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
	if(i==20){
	new Thread(ft,"有返回值的线程").start();
	}
	}

	try{
	//（4）调用 FutureTask 对象的 get () 方法来获得子线程执行结束后的返回值
	System.out.println("子线程的返回值："+ft.get());
	} catch (InterruptedException e){
	e.printStackTrace();
	} catch (ExecutionException e){
	e.printStackTrace();
	}

	}

	// （1）创建 Callable 接口的实现类，并实现 call () 方法，该 call () 方法将作为线程执行体，并且有返回值。
	@Override
	public Integer call() throws Exception{
	int i = 0;
	for(;i<100;i++){
	System.out.println(Thread.currentThread().getName()+" "+i);
	}
	return i;
	}

	}

三种方式的比较：

采用实现 Runnable、Callable 接口的方式创见多线程时，优势是：在这种方式下，多个线程可以共享同一个 target 对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将 CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：编程稍微复杂，如果要访问当前线程，则必须使用 Thread.currentThread () 方法。

这个会单独出一篇详细介绍。ヾ (◍°∇°◍)ﾉﾞ

Java 中提供了两种方法来启动其它进程：
方法一：
Process process = new ProcessBuilder(cmd).start();
方法二：
Process process = Runtime.getRuntime().exec(cmd);
注意：底层也是调用方法一。

方法 run 在 Runnable 接口中被定义，方法 start 在 Thread 类中被定义。

创建一个 Thread 类的实例，即为创建了一个处于初始状态的线程。对一个处于初始状态的线程调用方法 start，该线程被启动，进入运行状态。调用方法 start 之后，方法 run 会自动执行。

eg: 用线程实现定时器功能：

	public class Task {

	public static void main(String[] args) {
	// run in a second
	final long timeInterval = 1000;
	Runnable runnable = new Runnable() {
	@Override
	public void run() {
	while (true) {
	System.out.println("Hello !!");
	try {
	Thread.sleep(timeInterval);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}
	}
	};
	Thread thread = new Thread(runnable);
	thread.start();
	}
	}

启动线程时，为什么要通过调用方法 start 执行方法 run ，而不能直接执行方法 run ？ 10。
通过调用方法 start，执行方法 run，才是多线程工作。如果直接执行方法 run，则方法 run 会被当成一个主线程下的普通方法执行，而不会在某个线程中执行，因此不是多线程工作。
8.4
为什么需要使用多线程？10。
线程是程序执行的最小单位，多个线程同时运行可以减少线程上下文切换的开销。多线程是开发高并发系统的基础（即允许在同一时间段执行多个任务），利用好多线程机制可以显著提高系统的并发能力和性能。
8.4