进程与线程
进程
程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至
CPU
，数据加载至内存。在
指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理
IO
的
当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器
等），也有的程序只能启动一个实例进程（例如网易云音乐、
360
安全卫士等）
线程
一个进程之内可以分为一到多个线程。
一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给
CPU
执行
Java
中，线程作为最小调度单位，进程作为资源分配的最小单位。 在
windows
中进程是不活动的，只是作 为线程的容器
线程进程对比：
-
进程基本上相互独立的，而线程存在于进程内，是进程的一个子集
-
进程拥有共享的资源，如内存空间等，供其内部的线程共享
-
进程间通信较为复杂
同一台计算机的进程通信称为 IPC（Inter-process communication）
- 信号量：信号量是一个计数器，用于多进程对共享数据的访问，解决同步相关的问题并避免竞争条件
- 共享存储：多个进程可以访问同一块内存空间，需要使用信号量用来同步对共享存储的访问
- 管道通信：管道是用于连接一个读进程和一个写进程以实现它们之间通信的一个共享文件 pipe 文件，该文件同一时间只允许一个进程访问，所以只支持半双工通信
- 匿名管道（Pipes）：用于具有亲缘关系的父子进程间或者兄弟进程之间的通信
- 命名管道（Names Pipes）：以磁盘文件的方式存在，可以实现本机任意两个进程通信，遵循 FIFO
- 消息队列：内核中存储消息的链表，由消息队列标识符标识，能在不同进程之间提供全双工通信，对比管道：
- 匿名管道存在于内存中的文件；命名管道存在于实际的磁盘介质或者文件系统；消息队列存放在内核中，只有在内核重启（操作系统重启）或者显示地删除一个消息队列时，该消息队列才被真正删除
- 读进程可以根据消息类型有选择地接收消息，而不像 FIFO 那样只能默认地接收
不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP
- 套接字：与其它通信机制不同的是，可用于不同机器间的互相通信
-
线程通信相对简单，因为线程之间共享进程内的内存，一个例子是多个线程可以访问同一个共享变量
Java 中的通信机制：volatile、等待/通知机制、join 方式、InheritableThreadLocal、MappedByteBuffer
-
线程更轻量，线程上下文切换成本一般上要比进程上下文切换低
并行与并发
单核
cpu
下，线程实际还是
串行执行
的。操作系统中有一个组件叫做任务调度器，将
cpu
的时间片（
windows
下时间片最小约为
15
毫秒）分给不同的程序使用，只是由于
cpu
在线程间（时间片很短）的切换非常快，人类感
觉是
同时运行的
。总结为一句话就是：
微观串行，宏观并行
，
一般会将这种
线程轮流使用
CPU
的做法称为并发，
concurrent。
引用
Rob Pike
的一段描述：
并发（
concurrent
）是同一时间应对（
dealing with
）多件事情的能力
并行（
parallel
）是同一时间动手做（
doing
）多件事情的能力
例子
家庭主妇做饭、打扫卫生、给孩子喂奶，她一个人轮流交替做这多件事，这时就是并发
家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一 个人用锅时，另一个人就得等待）
雇了
3
个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行。
并发并行：
- 并行：在同一时刻，有多个指令在多个 CPU 上同时执行
- 并发：在同一时刻，有多个指令在单个 CPU 上交替执行
同步异步：
- 需要等待结果返回，才能继续运行就是同步
- 不需要等待结果返回，就能继续运行就是异步
创建线程的几种方式：
Thread
Thread 创建线程方式：创建线程类，匿名内部类方式
- start() 方法底层其实是给 CPU 注册当前线程，并且触发 run() 方法执行
- 线程的启动必须调用 start() 方法，如果线程直接调用 run() 方法，相当于变成了普通类的执行，此时主线程将只有执行该线程
- 建议线程先创建子线程，主线程的任务放在之后，否则主线程（main）永远是先执行完
Thread 构造器：
public Thread()public Thread(String name)
public class ThreadDemo {
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
for(int i = 0 ; i < 100 ; i++ ){
System.out.println("main线程" + i)
}
// main线程输出放在上面 就变成有先后顺序了，因为是 main 线程驱动的子线程运行
}
}
class MyThread extends Thread {
@Override
public void run() {
for(int i = 0 ; i < 100 ; i++ ) {
System.out.println("子线程输出："+i)
}
}
}
继承 Thread 类的优缺点：
- 优点：编码简单
- 缺点：线程类已经继承了 Thread 类无法继承其他类了，功能不能通过继承拓展（单继承的局限性）
Runnable
Runnable 创建线程方式：创建线程类，匿名内部类方式
Thread 的构造器：
public Thread(Runnable target)public Thread(Runnable target, String name)
public class ThreadDemo {
public static void main(String[] args) {
Runnable target = new MyRunnable();
Thread t1 = new Thread(target,"1号线程");
t1.start();
Thread t2 = new Thread(target);//Thread-0
}
}
public class MyRunnable implements Runnable{
@Override
public void run() {
for(int i = 0 ; i < 10 ; i++ ){
System.out.println(Thread.currentThread().getName() + "->" + i);
}
}
}
Thread 类本身也是实现了 Runnable 接口，Thread 类中持有 Runnable 的属性，执行线程 run 方法底层是调用 Runnable#run：
public class Thread implements Runnable {
private Runnable target;
public void run() {
if (target != null) {
// 底层调用的是 Runnable 的 run 方法
target.run();
}
}
}
Runnable 方式的优缺点：
-
缺点：代码复杂一点。
-
优点：
-
线程任务类只是实现了 Runnable 接口，可以继续继承其他类，避免了单继承的局限性
-
同一个线程任务对象可以被包装成多个线程对象
-
适合多个多个线程去共享同一个资源
-
实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立
-
线程池可以放入实现 Runnable 或 Callable 线程任务对象
-
Callable
实现 Callable 接口：
- 定义一个线程任务类实现 Callable 接口，申明线程执行的结果类型
- 重写线程任务类的 call 方法，这个方法可以直接返回执行的结果
- 创建一个 Callable 的线程任务对象
- 把 Callable 的线程任务对象包装成一个未来任务对象
- 把未来任务对象包装成线程对象
- 调用线程的 start() 方法启动线程
public FutureTask(Callable<V> callable)：未来任务对象，在线程执行完后得到线程的执行结果
- FutureTask 就是 Runnable 对象，因为 Thread 类只能执行 Runnable 实例的任务对象，所以把 Callable 包装成未来任务对象
- 线程池部分详解了 FutureTask 的源码
public V get()：同步等待 task 执行完毕的结果，如果在线程中获取另一个线程执行结果，会阻塞等待，用于线程同步
- get() 线程会阻塞等待任务执行完成
- run() 执行完后会把结果设置到 FutureTask 的一个成员变量，get() 线程可以获取到该变量的值
优缺点：
- 优点：同 Runnable，并且能得到线程执行的结果
- 缺点：编码复杂
public class ThreadDemo {
public static void main(String[] args) {
Callable call = new MyCallable();
FutureTask<String> task = new FutureTask<>(call);
Thread t = new Thread(task);
t.start();
try {
String s = task.get(); // 获取call方法返回的结果（正常/异常结果）
System.out.println(s);
} catch (Exception e) {
e.printStackTrace();
}
}
public class MyCallable implements Callable<String> {
@Override//重写线程任务类方法
public String call() throws Exception {
return Thread.currentThread().getName() + "->" + "Hello World";
}
}
1439
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
