并发编程笔记

2、进程&线程

2.1进程与线程

• 进程：进程是代码在数据集合上的一次运行活动，是系统资源分配和调度的基本单位。
• 线程：线城是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。

辅助解释：

进程：

程序由指令和数据组成，但这些指令要运⾏，数据要读写，就必须将指令加载⾄ CPU，数据

加载⾄内存。在指令运⾏过程中还需要⽤到磁盘、⽹络等设备。

●
进程是⽤来加载指令、管理内存、管理 IO 的

●
当⼀个程序被运⾏，从磁盘加载这个程序的代码⾄内存，这时就开启了⼀个进程。

●
进程就可以视为程序的⼀个实例。⼤部分程序可以同时运⾏多个实例进程（例如记事本、画

图、浏览器等），也有的程序只能启动⼀个实例进程（例如⽹易云⾳乐、360 安全卫⼠等）

线程：

●
⼀个进程之内可以分为⼀到多个线程。

●
⼀个线程就是⼀个指令流，将指令流中的⼀条条指令以⼀定的顺序交给 CPU 执⾏

●
Java 中，线程作为最⼩调度单位，进程作为资源分配的最⼩单位。

●
在 windows 中进程是不活动的，只是作为线程的容器

2.2线程与进程的比较

2.3、并发与并行

从操作系统的⾓度来看，线程是
CPU
分配的最⼩单位。

• 并⾏就是同⼀时刻，两个线程都在执⾏。这就要求有两个CPU去分别执⾏两个线程。
• 并发就是同⼀时刻，只有⼀个执⾏，但是⼀个时间段内，两个线程都执⾏了。并发的实现依赖于 CPU切换线程，因为切换的时间特别短，所以基本对于⽤户是⽆感知的。

2.4应用

2.4.1异步调⽤：

在异步调⽤中，调⽤⽅通常需要提供⼀个回调函数，⽤于接收异步操作的结果。当异步操作完成后，会 直接调⽤

回调函数并将结果传递给它。这样可以让调⽤⽅在异步操作执⾏的过程中继续执⾏其他任务，等到异步 操作完成

后再处理回调结果。这种⽅式可以提⾼程序的并发性和响应速度。

2.4.2多线程提升效率

public class aa extends Thread {
 public static void main(String[] args) {
 Thread t = new Thread() {
 @Override
 public void run() {
 System.out.println("通过Thread⽅式创建线程");
 }
 };
 t.run();
 //t.start();
 }
}

加星：继承Thead类，重写run方法，调用start（）方法启动线程。

public class ThreadTest {
 /**
 * 继 承Thread类
 * /
 public static class MyThread extends Thread {
 @Override
 public void run () {
 System . out . println ( "This is child thread" ) ;
 }
 }
 public static void main ( String [] args) {
 MyThread thread = new MyThread ();
 thread .start();
 }
}

• Thread 代表线程
• Runnable代表可运⾏的任务（线程要执⾏的任务）

public class aa extends Thread {
 public static void main(String[] args) {
 Runnable r = new Runnable() {
 @Override
 public void run() {
 System.out.println("使⽤Thread配合Runnable创建线程");
 }
 };
 //创建线程对象
 Thread thread = new Thread(r);
 //启动线程
 thread.start();
 }
}

public class RunnableTask implements Runnable {
 public void run () {
 System . out . println ( "Runnable!" ) ;
 }
 public static void main ( String [] args) {
 RunnableTask task = new RunnableTask ();
 new Thread ( task ) .start();
 }
}

public class CallerTask implements Callable < String > {
 public String call () throws Exception {
 return "Hello,i am running!" ;
 }

public static void main ( String [] args) {
 / /创建异步任务
 FutureTask < String > task = new FutureTask < String > ( new CallerTask ());
 / /启动线程
 new Thread ( task ) .start();
 try {
 / /等 待 执 ⾏ 完 成 ，并获取返回结果
 String result = task . get();
 System . out . println ( result) ;
 } catch ( InterruptedException e ) {
 e . printStackTrace ();
 } catch ( ExecutionException e ) {
 e . printStackTrace ();
 }
 }
}

思考：

●
线程是交替执⾏的

●
谁先谁后，不由我们控制

●
需要多核CPU，单核带不动

3.2.查看进程线程的⽅法

● top -H -p 查看某个进程（PID）的所有线程

3.3.线程运⾏原理

当 线程上下⽂切换Context Switch 发⽣时，需要由
操作系统保存当前线程的状态
，并恢复另⼀ 个线程的状态。

Java 中对应的概念就是程序计数器（Program Counter Register），它的作⽤是记住下⼀条

jvm 指令的执⾏地址，是线程私有的

3.4线程有哪些常⽤的调度⽅法？

• wait(long timeout) ：这个⽅法相⽐ wait() ⽅法多了⼀个超时参数，它的不同之处在于，如果线 程A调⽤共享对象的wait(long timeout)⽅法后，没有在指定的 timeout ms时间内被其它线程唤 醒，那么这个⽅法还是会因为超时⽽返回。
• wait(long timeout, int nanos)，其内部调⽤的是 wait(long timout）函数。
• 上⾯是线程等待的⽅法，⽽唤醒线程主要是下⾯两个⽅法：notify() : ⼀个线程A调⽤共享对象的 notify() ⽅法后，会唤醒⼀个在这个共享变量上调⽤ wait 系列⽅法后被挂起的线程。 ⼀个共享变量上可能会有多个线程在等待，具体唤醒哪个等待的线程 是随机的。
• notifyAll() ：不同于在共享变量上调⽤ notify() 函数会唤醒被阻塞到该共享变量上的⼀个线程，
• notifyAll()⽅法则会唤醒所有在该共享变量上由于调⽤ wait 系列⽅法⽽被挂起的线程。
• Thread类也提供了⼀个⽅法⽤于等待的⽅法：
• join()：如果⼀个线程A执⾏了thread.join()语句，其含义是：当前线程A等待thread线程终⽌之
• 后才 从thread.join()返回。

• sleep(long millis) :Thread类中的静态⽅法，当⼀个执⾏中的线程A调⽤了Thread 的sleep⽅法 后，线程A会暂时让出指定时间的执⾏权，但是线程A所拥有的监视器资源，⽐如锁还是持有不让 出的。指定的睡眠时间到了后该函数会正常返回，接着参与 CPU 的调度，获取到 CPU 资源后就 可以继续运⾏。

• yield() ：Thread类中的静态⽅法，当⼀个线程调⽤ yield ⽅法时，实际就是在暗⽰线程调度器当 前线程请求让出⾃⼰的CPU ，但是线程调度器可以⽆条件忽略这个暗⽰。 

• boolean isInterrupted() ⽅法： 检测当前线程是否被中断。
• boolean interrupted() ⽅法： 检测当前线程是否被中断，与 isInterrupted 不同的是，该⽅法如 果发现当前线程被中断，则会清除中断标志

1. start和run

public static void main(String[] args) {
 //创建线程
 Thread t1 = new Thread("t1") {
 @Override
 public void run() {
 log.debug(Thread.currentThread().getName());
 FileReader.read(Constants.MP4_FULL_PATH);
 }
 };
 //运⾏线程
 t1.run();
 log.debug("do other things ...");
}

需要注意的是，在Java中
不能直接调⽤run()⽅法来启动线程，必须使⽤start()⽅法来启动线程。

start()⽅法会为线程创建⼀个新的执⾏路径，并在该路径上调⽤run()⽅法。

如果直接调⽤run()⽅法，则不会创建新的执⾏路径，⽽是在当前线程上执⾏run()⽅法，这样就失去了 多线程的意义。

2. sleep和yield

while(true) {
 try {
 Thread.sleep(50);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
}

• 可以⽤wait或条件变量达到类似的效果
• 不同的是，后两种都需要加锁，并且需要响应的唤醒操作，⼀般适⽤于要进⾏同步的场景
• sleep适⽤于⽆需锁同步的场景

synchronized(锁对象) {
 while(条件不满⾜) {
 try {
 锁对象.wait();
 } catch(InterruptedException e) {
 e.printStackTrace();
 }
 }
// do sth...
}

lock.lock();
try {
while(条件不满⾜) {
try {
条件变量.await();//当前线程休眠
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// do sth...
} finally {
lock.unlock();
}

static int r = 0;
public static void main(String[] args) throws InterruptedException {
test1();
}
private static void test1() throws InterruptedException {
 log.debug("开始");
 Thread t1 = new Thread(() -> {
 log.debug("开始");
 sleep(1);
 log.debug("结束");
 r = 10;
 });
 t1.start();
 log.debug("结果为:{}", r);
 log.debug("结束");
}

结果是：开始..开始..结果为0..结束..结束…..

• 主线程和线程 t1 是并⾏执⾏的，t1 线程需要 1 秒之后才能算出 r=10
• ⽽主线程⼀开始就要打印 r 的结果，所以只能打印出 r=0

static int result = 0;
private static void test1() throws InterruptedException {
 log.debug("开始");
 Thread t1 = new Thread(() -> {
 log.debug("开始");
 sleep(1);
 log.debug("结束");
 result = 10;
 }, "t1");
 t1.start();
 t1.join();
 log.debug("结果为:{}", result);
}

private static void test2() throws InterruptedException {
 Thread t1 = new Thread(() -> {
 sleep(1);
 r1 = 10;
 });
 Thread t2 = new Thread(() -> {
 sleep(2);
 r2 = 20;
 });
 t1.start();
 t2.start();
 long start = System.currentTimeMillis();
 log.debug("join begin");
 t1.join();
 log.debug("t1 join end");
 t2.join();
 log.debug("t2 join end");
 long end = System.currentTimeMillis();
 log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

• 第⼀个 join：等待 t1 时, t2 并没有停⽌, ⽽在运⾏
• 第⼆个 join：1s 后, 执⾏到此, t2 也运⾏了 1s, 因此也只需再等待 1s

4.interrupt

private static void test1() throws InterruptedException {
 Thread t1 = new Thread(()->{
 sleep(1);
 }, "t1");
 t1.start();
 sleep(0.5);
 t1.interrupt();
 log.debug(" 打断状态: {}", t1.isInterrupted());
}

• 在调⽤sleep时执⾏打断会出现异常；
• sleep在调⽤时会清除打断标记
• 异常被caych了不会终⽌程序

private static void test2() throws InterruptedException {
 Thread t2 = new Thread(()->{
 while(true) {
 Thread current = Thread.currentThread();
 boolean interrupted = current.isInterrupted();
 if(interrupted) {
 log.debug(" 打断状态: {}", interrupted);
 break;
 }
 }
 }, "t2");
 t2.start();
 sleep(0.5);
 t2.interrupt();
 }

private static void test3() {
 Thread t1 = new Thread(() -> {
 log.debug("park...");
 LockSupport.park();
 log.debug("unpark...");
 log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
 }, "t1");
 t1.start();
 sleep(0.5);
 t1.interrupt();
}

class TPTInterrupt {
private Thread thread;
public void start(){

thread = new Thread(() -> {

while(true) {

Thread current = Thread.currentThread();

if(current.isInterrupted()) {

log.debug("料理后事");

break;

}

try {

Thread.sleep(1000);

log.debug("将结果保存");
} catch (InterruptedException e) {

current.interrupt();
}
// 执⾏监控操作
}
},"监控线程");
thread.start();
}

public void stop() {

thread.interrupt();
}
}

TPTInterrupt t = new TPTInterrupt();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

// 停⽌标记⽤ volatile 是为了保证该变量在多个线程之间的可⻅性
// 我们的例⼦中，即主线程把它修改为 true 对 t1 线程可⻅
class TPTVolatile {
 private Thread thread;
 private volatile boolean stop = false;
 public void start(){
 thread = new Thread(() -> {
 while(true) {
 Thread current = Thread.currentThread();
 if(stop) {
 log.debug("料理后事");
 break;
 }
 try {
 Thread.sleep(1000);
 log.debug("将结果保存");
 } catch (InterruptedException e) {
 
 }
 // 执⾏监控操作
 }
 },"监控线程");
 thread.start();
 }
 
 public void stop() {
 stop = true;
 thread.interrupt();
 }
}

TPTVolatile t = new TPTVolatile();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

3.5主线程与守护线程

3.6线程有几种状态

今天先更新到这里。