标签：extends 分配 总结 缺点 rac ati 状态 table 其他
程序就是一堆静态的代码，存储在硬盘上。程序如果不运行，本质就是一个文件。
程序一次运行产生进程，进程一直向前运行，直到进程结束。
单任务操作系统:一段时间只能运行一个程序(任务)。CPU利用率非常低。
|
|/
引入进程的概念
把程序的一次运行产生进程(内存空间、资源、程序的执行堆栈)
进程作为操作系统分配资源的基本单位。
|
|/
多任务操作系统
一台电脑就一个CPU，多个任务轮流使用CPU，从宏观上看，一段时间有多个任务正在运行。
从微观上看，一个时间点只有一个任务在运行。
CPU时间片
多个进程通过CPU时间片轮转实现多任务(进程)。把这种现象叫做并发操作
并行:
一个时间段，多个任务同时进行，多个CPU运行各自的进行。
|
|/
线程的引入
解决实时性问题
|
|
综合性案例
Thread 类位于java.lang中，表示进程中的执行线程。实现多线程有两种方式
|
public class MyThread extends Thread {
@Override public void run() { System.out.println("我是多线程MyThread"); for (int i = 0; i < 5; i++) { System.out.println("MyThread:" + i); } } }
|
|
public class Test01 { public static void main(String[] args) {
// main开始运行产生一个进程，该进程默认有个主(main)线程 // 创建线程 MyThread t1 = new MyThread(); // 启动线程 t1.start();
for (int i = 0; i < 5; i++) { System.out.println("main Thread:" + i); }
} } |
main线程和t1线程抢占CPU 执行。多线程在提高CPU利用率的同时，增加程序的复杂度。
|
public class MyRun implements Runnable {
@Override public void run() { System.out.println("我是MyRun"); for (int i = 0; i < 5; i++) { System.out.println("my run:" + i); } } }
|
|
public class Test02 { public static void main(String[] args) {
MyRun run = new MyRun(); Thread t1 = new Thread(run); t1.start();
// main开始运行产生一个进程，该进程默认有个主(main)线程 for (int i = 0; i < 5; i++) { System.out.println("main Thread:" + i); } } } |
卖票案例
继承Thread和实现Runnable接口实现多线程的优缺点
[1] 继承Thread的线程类不能再继承其他类，实现Runnable接口的类还可以继承其他类。
[2] 实现Runnable接口的线程类，可以让多个线程共享线程实现类的资源。
总结:
多线程提高了cpu利用率，但程序的复杂度也随之增加。一旦线程开始执行，很难通过其他方式控制线程的轨迹。
多个线程抢占CPU导致线程的运行轨迹不确定。
分析运行轨迹(A)
|
窗口A卖出一张票，还剩4张票 窗口B卖出一张票，还剩3张票 窗口B卖出一张票，还剩0张票 窗口C卖出一张票，还剩1张票 窗口A卖出一张票，还剩2张票 |
|
窗口A抢占到CPU，执行run，count=5 public void run() { // 模拟一个窗口5个人 for (int i = 0; i < 5; i++) { if (count > 0) { count--; System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } |
|
窗口B抢占到CPU，count=4，执行run public void run() { // 模拟一个窗口5个人 for (int i = 0; i < 5; i++) { if (count > 0) { count--; System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } |
|
窗口A到抢占CPU，count=3，执行run public void run() { // 模拟一个窗口5个人 for (int i = 0; i < 5; i++) { if (count > 0) { count--; => count=2 System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } |
|
窗口C到抢占CPU，count=2，执行run public void run() { // 模拟一个窗口5个人 for (int i = 0; i < 5; i++) { if (count > 0) { count--; => count=1 System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } |
|
窗口B抢占CPU，count=1，从上次挂起的位置开始执行run public void run() { // 模拟一个窗口5个人 for (int i = 0; i < 5; i++) { if (count > 0) { count--; System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); => count=0 } } } |
|
窗口C抢占到CPU，count=0，从上次挂起位置开始执行run public void run() { // 模拟一个窗口5个人 for (int i = 0; i < 5; i++) { if (count > 0) { count--; => count=1 System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } |
|
窗口A抢占到CPU，count=0，从上次挂起的位置开始执行run public void run() { // 模拟一个窗口5个人 for (int i = 0; i < 5; i++) { if (count > 0) { count--; => count=2 System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } |
结论
[1]多线程抢占CPU执行，可能在任意位置被切换出去(挂起)。
[2]多线程抢占到CPU后，从上次挂起的位置开始执行(先恢复上次的执行堆栈)。
[3]多线程都可以独立运行，相互不干扰，多个线程都可以能访问共享资源，很容易导致数据错乱！！！
|
新生状态 用new关键字建立一个线程后，该线程对象就处于新生状态。 处于新生状态的线程有自己的内存空间，通过调用start()方法进入就绪状态。
就绪状态 处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU。 当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为“CPU调度”。 运行状态 在运行状态的线程执行自己的run方法中代码,直到等待某资源而阻塞或完成任何而死亡。 如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。 阻塞状态 处于运行状态的线程在某些情况下，如执行了sleep(睡眠)方法，或等待I/O设备等资源，将让出CPU并暂时停止自己运行，进入阻塞状态。 在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。 死亡状态 死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有三个，一个是正常运行 的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过stop方法来终止一个 线程【不推荐使用】；三是线程抛出未捕获的异常。
|
|
public static void main(String[] args) {
System.out.println(Thread.MIN_PRIORITY); System.out.println(Thread.MAX_PRIORITY); System.out.println(Thread.NORM_PRIORITY);
//主线程的优先级（默认优先级） System.out.println(Thread.currentThread().getPriority());
Thread01 t1 = new Thread01(); // 设置线程的优先级 t1.setPriority(Thread.MAX_PRIORITY); t1.start();
Thread01 t2 = new Thread01(); // 设置线程的优先级 t2.setPriority(Thread.MIN_PRIORITY); t2.start();
} |
线程优先级高，被cpu调度的概率大，不表示一定先运行。
判断线程是否处于活动状态。
|
Thread01 t1 = new Thread01(); System.out.println(t1.isAlive()); // 设置线程的优先级 t1.setPriority(Thread.MAX_PRIORITY); t1.start(); System.out.println(t1.isAlive()); |
线程调用start之后就处于活动状态。
调用该方法的线程强制执行，其它线程处于阻塞状态，该线程执行完毕后，其它线程再执行
join称为线程的强制执行，有可能被外界中断产生InterruptedException 中断异常。
|
public class Test02 { public static void main(String[] args){
Thread02 t = new Thread02("线程A"); t.start();
for (int i = 0; i < 5; i++) {
if(i == 2) { try { t.join(); } catch (InterruptedException e) { e.printStackTrace(); } }
System.out.println(Thread.currentThread().getName() + "->" + i); } } } |
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。休眠的线程进入阻塞状态。
|
public static void main(String[] args) {
Thread03 t = new Thread03("线程A"); t.start();
Thread mainThread = Thread.currentThread(); System.out.println(mainThread.getName()+"即将进入休眠"); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); }
// 中断线程 t.interrupt();
System.out.println(mainThread.getName()+"休眠完成"); } |
|
public static void main(String[] args) {
Thread mainThread = Thread.currentThread();
Thread04 t = new Thread04("线程A"); t.start();
for (int i = 0; i < 5; i++) { if (i == 2) { // yield 使当前礼让一次 Thread.yield(); } System.out.println(mainThread.getName() + "->" + i); } } |
A hint to the scheduler that the current thread is willing to yield its current use of a processor. The scheduler is free to ignore this hint.
当前线程给cpu调度器一个暗示，暗示其想礼让一次其拥有的cpu，CPU调度者也可以狐狸这次暗示。此时当前线程进入就绪状态。
[6] 线程的终止。
目前而言，不推荐使用stop直接终止线程。用interrupt()方法去中断正在执行的线程，而在线程内部一定要写捕获中断的异常。通过异常处理机制正常结束线程。
线程在执行过程中，通过cpu的调度，执行轨迹不确定，对共享资源的访问很容易造成数据的错误。我们称这个错乱称为线程安全问题。
原子性操作:一个操作要么一次性做完，要么根本不开始，不存在中间状态。
案例:ATM取现操作
同步就是让操作保持原子性！java提供两种方式实现同步。
把所有的同步操作放到同步代码块中，
|
synchronized (mutex) { // .. . } |
mutex 称为互斥锁/同步锁。对共享资源进行加锁实现同步。一般用共享资源作为同步锁，也称同步监视器。
|
public class MyRun implements Runnable {
// 共享资源 private int count = 5;
@Override public void run() { // 模拟一个窗口5个人 for (int i = 0; i < 5; i++) { // 同步代码块 // mutex 互斥锁 synchronized (this) { if (count > 0) {
try { Thread.sleep(3000); count--; } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } } } |
总结
synchronized(obj){}中的obj称为同步监视器
同步代码块中同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器
如果同步代码(原子性)很多，可以考虑使用同步方法。
把普通方法用 synchronized 修饰，同步方法的同步监视器是this。
|
public class MyRun implements Runnable {
// 共享资源 private int count = 5;
@Override public void run() { // 模拟一个窗口5个人 for (int i = 0; i < 5; i++) {
this.saleTicket();
} }
// 同步方法默认对this加锁 private synchronized void saleTicket() { if (count > 0) {
try { Thread.sleep(3000); count--; } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } |
线程t1，拥有A资源，再次申请B资源，线程t2,拥有B资源，再申请A资源，t1因为没有申请到B资源而进入阻塞；t2因为没有申请到A资源进入阻塞。此时两个线程都处于阻塞状态而不能正常结束，而此时cpu空转，这种情况称为死锁。
标签：extends 分配 总结 缺点 rac ati 状态 table 其他
原文地址：https://www.cnblogs.com/onePG/p/10841052.html
