多线程
进程
每一个应用程序在运行时，都会产生至少一个进程（process）。
进程是操作系统进行“资源分配和调度”的独立单位。
Windows系统的“任务管理器”可以查看系统的进程，通过Ctrl+Shift+Esc组合键可以调出“任务管理器”。
进程具有三个特征：
- 独立性：进程拥有自己独立的资源，有私有的地址空间。
- 动态性：程序是静态的指令集合，而进程是活动的指令集合，进程有其生命周期。
- 并发性：多个进程可以在同一个处理器上并发执行，互不影响。虽然同一时刻只能有一个进程执行，但是多个进程被快速轮换执行（时间片轮换算法），宏观上有同时执行的效果（同一时间段内执行）。
现代的操作系统都支持多进程并发执行。
线程
? 线程（Thread）是执行特定任务的最小单位，是进程的执行单元，也被称为轻量级进程（Lightweight Process）。
? 一个进程至少有一个线程，也可以有多个线程。所谓多线程就是指同一个进程可以同时并发处理多个任务。
? 线程没有系统资源，多个线程共享其所属进程的系统资源，因此多线程运行时，需要处理好资源同步问题。
总结：
- 操作系统可以同时执行多个任务，每个任务是一个进程；
- 进程可以同时执行多个任务，每个任务是一个线程。
多线程的优点
多线程就是下图这种感觉：
对计算机来说，多线程可以提高CPU的利用率。
例如：网络的数据传输速率远低于计算机的处理能力，如果是单线程程序，在下载网络资源时，CPU需要花费大量的空闲时间来等待，而多线程能够利用这些空闲时间完成其他任务。
具体来说：
|--一个浏览器可以在下载的同时打开其他网页；
|--Web服务器可以同时相应多个用户请求；
|--QQ发送文件的时候还能跟其他人继续聊天……
当前线程
Thread.currentThread()：获取当前线程
.getName()：获取线程名称
public class TestMainThread {
public static void main(String[] args) {
// 获得当前运行的线程
Thread tMain = Thread.currentThread();
// 线程名称，优先级，线程组
System.out.println("当前运行的线程是：" + tMain);
System.out.println("线程名称：" + tMain.getName());
}
}当前运行的线程是：Thread[main,5,main]
线程名称：main
创建线程
方法1：继承Thread类
Thread类代表线程，所有的线程对象都是Thread类或其子类的对象。
创建线程的步骤：
- 继承Thread类
- 重写run()方法（线程执行体）
- 创建Thread类的实例对象
- 调用start()方法启动线程
可以使用setName(…)为线程设置名字，用getName()获取。
默认情况下，主线程名为main，子线程名为Thread-0、Thread-1等。
public class _11NewThread {
public static void main(String[] args) {
Thread t1 = new MyT();
t1.setName("1");
t1.start();
Thread t2 = new MyT();
t2.setName(" 2");
t2.start();
}
}
class MyT extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程:" + super.getName());
}
}
}方法2：实现Runnable接口
Runnable是个接口，实现Runnable接口的类还可以继承其它类，这是比方法1优越的地方。
- 实现Runable接口
- 重写run()方法
- 创建Runable对象
- 创建Thread对象
- 调用thread.start()方法，启动线程
实际创建的对象还是Thread实例。
public class _12NewThreadRunnable {
public static void main(String[] args) {
MyR r1 = new MyR("A");
Thread t1 = new Thread(r1);
t1.setName("XXX");
t1.start();
MyR r2 = new MyR(" B");
Thread t2 = new Thread(r2);
t2.start();
}
}
class MyR implements Runnable {
public MyR(String s) {
this.s = s;
}
private String s;
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程:" + s);
}
}
}
*方法3：实现Callable接口
使用Callable和FutureTask创建线程——可以获取线程的返回值。这种做法了解即可。
- 实现Callable接口的线程，需重写call()方法，有返回值
- 需要FutureTask类包装一下Callablle，该类实现了Runable接口
- 以Future对象为参数创建线程，调用start()方法启动
- 以Futrue对象.get()接收返回值
package ahjava.p06thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
// 实现Callable接口的线程，需重写call()方法，有返回值
// 需要FutureTask类包装一下Callablle，该类实现了Runable接口
// 以Future对象为参数创建线程，调用start()方法启动
// 以Futrue对象.get()接收返回值
public class _13NewThreadCallable {
public static void main(String[] args) {
MyCallable _Callable = new MyCallable("A");
FutureTask<String> _FutureTask = new FutureTask<>(_Callable);
Thread _Thread = new Thread(_FutureTask);
_Thread.start();
try {
// 模拟等待，此过程可看到子线程在执行
Thread.sleep(3000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
// 接受子线程的返回值
try {
String s = _FutureTask.get();
System.out.println("子线程的返回值 = " + s);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
class MyCallable implements Callable<String> {
public MyCallable(String s) {
this.s = s;
}
private String s;
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println("线程:" + s);
}
return "我是子线程，已经执行完毕";
}
}start()和run()
调用start()是开启新线程，调用run()是普通方法调用。
方法调用是入栈操作，调用完毕则出栈。
如果直接调用run()方法，则是在原线程中进行方法调用，用的还是之原线程的栈。
调用start()才是开启一个新线程，会创建新的栈。
线程的优先级
| 最高 | 10 | Thread.MAX_PRIORITY |
| 默认 | 5 | Thread.NORM_PRIORITY |
| 最低 | 1 | Thread.MIN_PRIORITY |
演示示例：
Thread(Runnable target, String name):为线程直接命名
Thread.currentThread():获取当前线程
public class Priority线程优先级 {
// *可能不太容易看出来
public static void main(String[] args) {
MyRu r1 = new MyRu();
MyRu r2 = new MyRu();
MyRu r3 = new MyRu();
Thread t1 = new Thread(r1);
// 创建时命名
Thread t2 = new Thread(r2, " B");
Thread t3 = new Thread(r3);
t1.setName("A");
t3.setName(" C");
t1.setPriority(Thread.MAX_PRIORITY);
t3.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
t3.start();
}
}
class MyRu implements Runnable {
@Override
public void run() {
String sName = Thread.currentThread().getName();
int sPri = Thread.currentThread().getPriority();
for (int i = 0; i < 100; i++) {
System.out.println("线程:" + sName + " 优先级:" + sPri);
}
}
}
多线程的运行结果是不确定的，运行结果每次不同，可能有些时候看不出不同优先级的区别。
原文地址：https://www.cnblogs.com/tigerlion/p/11179234.html