多线程
什么是进程？
应用程序的一次运行产生进程。
为什么存在进程的概念？
什么是线程
参考:https://www.cnblogs.com/geeta/p/9474051.html
线程和进程区别
案例:理解上课的进程
实现多线程
继承Thread类
|
package cn.sxt01.thread01;
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("MyThread:" + i);
}
}
}
|
|
package cn.sxt01.thread01;
public class Test01 {
public static void main(String[] args) {
// 【1】创建一个线程并执行
MyThread myThread = new MyThread();
myThread.start();
// main线程也称主线程
for (int i = 0; i < 10; i++) {
System.out.println("MainThread:" + i);
}
}
}
|
Test01中存在两个线程，一个是main线程，也称主线程。另外一个是myThread线程。
两个线程抢占CPU，所以程序运行轨迹不确定。
实现Runnable接口
Runnable接口表示实现类是否具有在多线程中执行的能力。
|
package cn.sxt01.thread01;
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("MyRunnable:" + i);
}
}
}
|
案例:卖票
|
package cn.sxt02.thread02;
public class TicketThread extends Thread {
private static int count = 5;
public TicketThread(String name) {
super(name);
}
@Override
public void run() {
// 模拟买票
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--;
System.out.println(super.getName() + "卖出一张,还剩" + count + "张");
}
}
}
}
|
|
窗口A卖出一张,还剩4张
窗口B卖出一张,还剩2张
窗口C卖出一张,还剩3张
窗口B卖出一张,还剩0张
窗口A卖出一张,还剩1张
|
分析运行轨迹
|
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--;
System.out.println(super.getName() + "卖出一张,还剩" + count + "张");
}
}
|
|
A抢占到CPU，count(5)，条件成立，count--，输出
窗口A卖出一张,还剩4张
C抢占到CPU，
|
|
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--;
System.out.println(super.getName() + "卖出一张,还剩" + count + "张");
}
}
|
|
C开始执行，执行到super.getName() + "卖出一张,还剩" + count + "张" 准备好，线程C挂起。
B抢占到CPU
|
|
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--;
System.out.println(super.getName() + "卖出一张,还剩" + count + "张");
}
}
|
|
B开始执行，指定到输出位置，输出
窗口B卖出一张,还剩2张
CPU时间片到，
|
|
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--;
System.out.println(super.getName() + "卖出一张,还剩" + count + "张");
}
}
|
|
C抢占到CPU，直接冲上次挂起位置开始执行，输出
窗口C卖出一张,还剩3张
|
结论:
[1]线程在执行过程中，在任意位置时，都有可能被挂起。下次抢占到cpu后，从挂起位置开始执行。
[2]当有多个线程访问共享数据时，会出现数据错乱。
[3]多线程提高了cpu利用率，但同时程序的复杂度增加。
|
public class MyRun implements Runnable {
private int count = 5;
@Override
public void run() {
// 模拟买票
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--;
System.out.println(Thread.currentThread().getName()+"卖出一张,还剩" + count + "张");
}
}
}
}
|
|
package cn.sxt02.thread02;
public class Test02 {
public static void main(String[] args) {
MyRun run = new MyRun();
Thread t1 = new Thread(run,"窗口A");
Thread t2 = new Thread(run,"窗口B");
Thread t3 = new Thread(run,"窗口C");
t1.start();
t2.start();
t3.start();
}
}
|
比较Thread和Runnable的区别
[1] 继承Thread的线程类不能再继承其他父类；而实现Runnable接口还可以继承其他类。
[2] 实现Runnable接口的线程实现类，更便于多个线程共享资源。
线程的生命周期
生命周期
新生状态
用new关键字建立一个线程后，该线程对象就处于新生状态。
处于新生状态的线程有自己的内存空间，通过调用start()方法进入就绪状态。
就绪状态
处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU。
当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为“CPU调度”。
运行状态
在运行状态的线程执行自己的run方法中代码,直到等待某资源而阻塞或完成任何而死亡。
如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。
阻塞状态
处于运行状态的线程在某些情况下，如执行了sleep(睡眠)方法，或等待I/O设备等资源，将让出CPU并暂时停止自己运行，进入阻塞状态。
在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。
死亡状态
死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有三个，一个是正常运行的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过stop方法来终止一个线程【不推荐使用】；三是线程抛出未捕获的异常。
线程常见方法
[1]优先级
|
package cn.sxt03.thread03;
public class Test02Priority {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getPriority());
// 线程优先级的最大最小默认值
System.out.println(Thread.MAX_PRIORITY);
System.out.println(Thread.MIN_PRIORITY);
System.out.println(Thread.NORM_PRIORITY);
Thread02 t2 = new Thread02("线程B");
t2.setPriority(Thread.NORM_PRIORITY);
Thread02 t1 = new Thread02("线程A");
t1.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();
}
}
|
线程优先级越大，表示被CPU调度的可能性增大，并不一定先执行。
[2]isAlive 检测线程是否处于活动状态。
|
package cn.sxt03.thread03;
public class Test03isAlive {
public static void main(String[] args) {
Thread t1 = new Thread("线程A");
System.out.println(t1.isAlive());
t1.start();
System.out.println(t1.isAlive());
}
}
|
[3]join 线程的强行执行
调用该方法的线程强制执行，其它线程处于阻塞状态，该线程执行完毕后，其它线程再执行
|
public class Test04Join {
public static void main(String[] args) {
Thread04 t1 = new Thread04("线程A");
t1.start();
for (int i = 0; i < 5; i++) {
if(i == 3) {
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("mainThread" + " i=" + i);
}
}
}
|
[4]sleep 线程休眠
当前线程休眠，线程进入阻塞状态。到休眠时间到，进入就绪状态。在休眠过程中线程可以被中断。
[5]yield 线程礼让
|
public class Test06Yield {
public static void main(String[] args) {
Thread06 t1 = new Thread06("线程A");
t1.start();
for (int i = 0; i < 5; i++) {
if(i == 3) {
Thread.yield();
}
System.out.println("mainThread" + " i=" + i);
}
}
}
|
|
可能的结果
mainThread i=0
mainThread i=1
mainThread i=2 => 主线程礼让一次，下次有可能调度主线程，也有可能调度t1
mainThread i=3
mainThread i=4
线程A i=0
线程A i=1
线程A i=2
线程A i=3
线程A i=4
|
线程礼让后，线程进入就绪状态。
线程礼让让当前线程进入就绪状态（礼让一次），但调度者有可能再次调度礼让的线程。
[6]stop 线程终止
线程终止存在安全隐患，容易导致被锁的资源无法释放，不建议使用。通常使用interrupt代替中断线程，中断线程并通过异常捕获，线程继续执行并正常结束。
线程安全
多线程中允许多个线程访问同一个资源(共享资源)，多个线程可以对共享资源进行破坏性操作容易导致数据错乱的问题。
原子性操作：逻辑上认为多句代码之间应该属于整体的，要么都执行，要么都不执行。不允许存在执行一半的情况。把这样的操作称为原子性操作。
同步代码块
如果是少量的代码，可以把原子性操作放入同步代码块中，使用关键字synchronized语法
|
synchronized ( 同步监视器/互斥锁 ){
原子性操作
}
|
同步监视器/互斥锁一定是对象类型。
|
package cn.sxt04.thread04;
public class MyRun implements Runnable {
private int count = 5;
@Override
public void run() {
// 模拟买票
for (int i = 0; i < 5; i++) {
// mutex 互斥锁
// 通常将当前对象作为同步对象/互斥锁
synchronized (this) {
if (count > 0) {
count--;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出一张,还剩" + count + "张");
}
}
}
}
}
|
同步代码块本质上是给共享资源加锁。锁会导致其他访问共享资源的线程阻塞。
同步方法
如果代码量多，可以考虑使用同步方法。
|
package cn.sxt04.thread04;
public class MyRun implements Runnable {
private int count = 5;
@Override
public void run() {
// 模拟排队买票
for (int i = 0; i < 5; i++) {
this.buyTicket();
}
}
// 同步方法默认把当前对象this加锁
public synchronized void buyTicket() {
if (count > 0) {
count--;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出一张,还剩" + count + "张");
}
}
}
|
同步监视器
- synchronized(obj){}中的obj称为同步监视器
- 同步代码块中同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的监视器是this，也就是该对象本身
同步监视器的执行过程
- 第一个线程访问，锁定同步监视器，执行其中代码
- 第二个线程访问，发现同步监视器被锁定，无法访问
- 第一个线程访问完毕，解锁同步监视器
- 第二个线程访问，发现同步监视器未锁，锁定并访问
死锁（C）
当线程A拥有一个资源r1,再去申请另外一个资源r2时；此时线程B拥有r2资源，再去申请r1，此时两个线程陷入互相等待，陷入阻塞，此时就绪队列为空，cpu空转。
|
package cn.sxt05.thread07;
public class ThreadA extends Thread{
private Object r1;
private Object r2;
public ThreadA(Object r1, Object r2) {
super();
this.r1 = r1;
this.r2 = r2;
}
@Override
public void run() {
synchronized (r1) {
System.out.println("已拥有r1");
synchronized (r2) {
System.out.println("想申请拥有r2");
}
}
}
}
|
