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() {@Overridepublic void run() {System.out.println("通过Thread⽅式创建线程");}};t.run();//t.start();}
}

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

public class ThreadTest {/*** 继 承Thread类* /public static class MyThread extends Thread {@Overridepublic 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() {@Overridepublic 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") {@Overridepublic 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线程有几种状态

今天先更新到这里。