【10分钟复习】java 多线程专题极速版 面试用

0、线程相关知识

0.1：程序：写好的代码

0.2：进程，运行中的程序

• 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程
  

0.3：线程

• 线程是由进程创建的，是进程的一个实体
• 一个进程可以拥有多个线程

0.4：其他相关概念

1. 单线程：同一个时刻，只允许执行一个线程
2. 多线程：同一个时刻，可以执行多个线程，比如一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

0.5：并发

0.6：并行

• 单核CPU执行的任务叫做并发
• 多核CPU执行的任务叫做并行
• 电脑上也有并发和并行同时有的情况

二、继承Thread创建线程

1.1：线程基本使用

1.2：线程应用案例1-继承Thread类

1.3：简单总结

案例1简单流程总结：

1. 程序从main方法中创建主线程main
2. 主线程中创建Thread01子线程
3. 主线程先结束执行，子线程Thread01后结束执行
4. 等到进程内线程全部结束，进程才会结束

1.4：为什么是start()而不是run()

• run方法只是一个普通的方法，并没有真的启动一个线程
• 如果是cat.run()，就会把run方法执行完毕，才会继续执行下面的代码
• 这样就变成串行执行，而不是并行
• start才会真正的执行一个线程

1.5: 简单总结p5

• 读start方法的源码发现
• start方法中调用了start0方法
• start0方法才是真正实现多线程的方法，由JVM虚拟机调用，是C/C++写的
• start0内部调用run方法

三、实现runnable接口，实现多线程

3.1 代理模式-静态代理

由于Thread内部实现了静态代理，所以复习一下

1. 什么是静态代理？例子：房东和房客
2. 房东-中介-房客，交易对象本来是房东和房客，加入代理以后交易对象变成房东-中介，中介-房客。换言之房东不直接和房客交易
3. 为什么要用代理？减少代码冗余，如果在原本写好的代码上新增代码，容易写错，加入代理后将代码写在代理上即可

多线程

写一个小案例，启动两个子线程

5.1 Thread和Runnable的区别

• 使用Runnable接口可以实现多个线程共享一个资源的情况（如图）

5.2 多线程售票系统

5.3.线程终止问题

public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
        Thread.sleep(4000);
        t.setLoop(false);
    }
}

class T extends Thread{
    boolean loop = true;
    @Override
    public void run() {
        int count=0;

        while (loop){
            System.out.println("我在运行、。。"+count++);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
    void setLoop(boolean loop){
        this.loop = loop;
    }
}

线程常用方法

用户进程和守护进程

线程的生命周期

线程同步

互斥锁

线程死锁

释放锁

题目1：B输入Q退出A的循环输出

/**
 * 写一个双线程程序
 * A线程打印整数，直到B线程输入Q
 * @author 86176
 */
public class HomeWork01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        a.start();
        b.start();
    }
}

class A extends Thread{
    static boolean flag = true;
    int count = 0;

    public static void setFlag(boolean flag) {
        A.flag = flag;
    }

    @Override
    public void run() {
        while (flag){
            System.out.println(count++);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class B extends Thread{
    @Override
    public void run() {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        if (s.equals("Q")){
            A.setFlag(false);
        }
    }
}

题目2：A和B一起取钱，取完退出

/**
 * 取钱案例，多线程
 * @author 86176
 */
public class TakeMoney {
    public static void main(String[] args) {
        Take take = new Take();
        Thread th1 = new Thread(take);
        Thread th2 = new Thread(take);
        th1.start();
        th2.start();
    }
}

class Take implements Runnable{
    int money = 10000;
    @Override
    public void run() {
        while (true){
            synchronized (this){
                if (money<1000){
                    System.out.println("余额不足，已退出");
                    break;
                }
                money = money-1000;
                System.out.println(Thread.currentThread().getName()+"取款成功，余额还剩，"+money);
                try {
                    Thread.sleep(400);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}