多线程<small>创建线程的三种方式</small>
进程和线程
几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程Process。当一个程序运行时，内部可能包含多个顺序执行流，每个顺序执行流就是一个线程Thread。
线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须拥有一个父进程。
线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但是线程不拥有自己的资源。它与父进程的其他线程共享该进程的所有资源。
线程的执行是抢占式的，所以任何一个线程都有可能被挂起，以便另外一个线程的执行。
线程可以创建和撤销另外一个线程。
线程共享的环境包括：进程的代码段，进程的共有数据等。利用这些共享的数据，线程很容易实现项目之间的通信。
1. 继承Thread类创建线程类
- 定义Thread类的子类，并重写run()方法，该run(0方法的方法体代表了线程需要完成的任务，因此run()方法称为线程执行体。
- 创建了Thread类的子类，级创建了线程对象。
- 调用线程对象的start()方法来启动该线程。
currenThread()，获取当前线程对象
getName()，当前线程的名字，默认是main ,Thread-0,Thread-1,Thread-n
package com.manyThread;
/**
* @author futao
* Created on 18-1-8-下午8:49.
* 多线程的实现方式1，继承Thread类，重写run()方法
*/
public class FirstThread extends Thread {
private int i;
@Override
public void run() {
for (; i < 1000; i++) {
System.out.println("==" + this.getName() + " " + i);
}
}
public static void main(String[] args) {
for (int i = 0; i < 1000; i++) {
System.out.println("main===" + Thread.currentThread().getName() + " " + i);
if (i == 20) {
FirstThread firstThread = new FirstThread();
firstThread.setName("Niu");
firstThread.start();
new FirstThread().start();
}
}
}
}
可以发现，i的值是不连续的，所以用继承Thread的方式实现的多线程是不能够共享线程的实例变量的。
使用继承Thread类的方法来创建线程时，多个线程之间无法共享线程的实例变量，因为每个线程都需要实例化一个对象。
2. 实现Runnable接口创建线程类
- 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真的线程对象。
package com.manyThread;
/**
* @author futao
* Created on 18-1-8-下午9:10.
* 多线程的实现方式2,实现Runnable接口,重写run()方法
*/
public class FirstRunnable implements Runnable {
private int i;
@Override
public void run() {
for (; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "===" + i);
}
}
public static void main(String[] args) {
for (int j = 0; j < 100; j++) {
System.out.println("main" + j);
if (j == 20) {
FirstRunnable firstRunnable = new FirstRunnable();
/*Runnable的实现类的对象仅仅用来作为new Thread()的target*/
Thread thread = new Thread(firstRunnable, "myNewThread");
thread.start();
Thread thread1 = new Thread(firstRunnable, "2thread");
thread1.start();
}
}
}
}
变量 i 的值是连续的，所以通过实现Runnable接口的方式实现的多线程是可以共享线程类的实例变量的
这是因为在这种方式下，程序所创建的Runnable对象只是线程的target，而多个线程可以共享同一个target，所以多个线程可以共享同一个线程类（实际上是线程的target类）的实例变量。
所以通过实现Runnable接口创建的多线程时，Thread类的作用就是把run()方法包装成线程执行体。
3.使用Callable和Future创建线程
Runnable接口的增强版
- 创建Callable接口的实现类，并实现call()方法,作为线程的执行体，且该call()方法有返回值，可以直接使用Lambda表达式创建Callable对象
- 使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
- 使用FutureTask对象作为Thread对象的target创建并且启动线程
- 调用FutureTask对象的get()方法来获得子线程执行之后的返回值。（将导致主线程被阻塞，直到call()方法返回返回值）
package com.manyThread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @author futao
* Created on 18-1-11-上午10:21.
*/
public class FirstCallable implements Callable {
@Override
public Object call() throws Exception {
return 6666;
}
public static void main(String[] args) {
// FirstCallable firstCallable = new FirstCallable();
// FutureTask futureTask = new FutureTask(firstCallable);
// Thread thread = new Thread(futureTask);
// thread.start();
// try {
// System.out.println(futureTask.get());
// } catch (InterruptedException e) {
// e.printStackTrace();
// } catch (ExecutionException e) {
// e.printStackTrace();
// }
FutureTask futureTask1 = new FutureTask(() -> {
int i = 0;
for (; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + i);
}
return i;
});
for (int i = 0; i < 50; i++) {
System.out.println(Thread.currentThread().getName() + i);
if (i == 20) {
Thread thread = new Thread(futureTask1);
thread.start();
try {
/*get()方法将导致主线程被阻塞，直到call()方法结束并返回返回值为止*/
System.out.println(futureTask1.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}
}
4. 创建线程的三种方式比较
0
