Java的第一遍学习笔记 线程基础

线程相关概念

程序

是为了完成特定任务，用某种语言编写的一组指令的集合。简单地说：就是我们写的代码。

进程

线程

其它

    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        //获取当前电脑的cpu数量
        int cpuNums = runtime.availableProcessors();
        System.out.println(cpuNums);
    }

线程基本使用

创建线程的两种方式

1. 继承Thread 类，重写 run方法。

    当一个类继承了 Thread 类，该类就可以当作线程使用。Thread类实现了 Runnable接口的run方法，我们会重写run，写上自己的业务代码。 下面是Thread类的run方法：

class AA extends Thread{
    @Override
    public void run() { //重写run方法
        while(true){
            System.out.println("线程进行中");
            try{
                //线程每输出一次，休眠一秒(不用try-catch会报异常)
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

    public static void main(String[] args) throws InterruptedException { //main线程
        AA aa = new AA();
        aa.start(); //启动子线程 Thread-0  下面会解释为什么不调用run
        //说明：当main线程启动一个子线程 Thread-0,主线程不会阻塞，会继续执行。
        //这时，主线程和子线程是交替进行的
        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        //获取线程名
        for(int i=0;i<10;i++){
            System.out.println("主线程" + i);
            Thread.sleep(1000); //alt + enter可以抛出异常
        }
    }

 注：子线程也可以开启另一个子线程。

    这里有一个值得注意的问题：AA类重写的是run方法，但是在main中调用的却是start，这是为什么呢？ 因为只有start方法才能启动线程，进而执行AA类的run方法。这时main和Thread-0是同步执行的。  如果调用run方法，这就是一个普通的方法，没有真正启动一个线程，因此会把run方法执行完再执行下面的内容，造成阻塞。 

    start会调用一个start0方法(这才是启动线程的方法)，下面是start的流程图。

2. Runnable创造线程

   当一个类已经有继承的父类时，就不能再继承Thread类了，这时可以实现Runnable接口来创造一个线程。

3. 当有多个线程共享资源时，一般用Runnable创造线程。 

class AA implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("线程进行中");
            try{
                //线程每输出一次，休眠一秒(不用try-catch会报异常)
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

    public static void main(String[] args) throws InterruptedException {
        AA aa = new AA();
        //aa.strat();  报错，因为没有继承Thread，不能直接调用start。
        Thread thread1 = new Thread(aa);//创建一个Thread，把类放入
        Thread thread2 = new Thread(aa)；//多个资源共享线程(同一个对象创造多个线程)
        thread1.start();
        thread2.start();
    }

模拟Thread类：

class ThreadProxy implements Runnable{
    private Runnable target = null; //类型是Runnable
    @Override
    public void run() {
        if(target!=null){
            target.run();
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start(){
        start0();
    }
    public void start0(){
        run();
    }
}

JConsole

这个工具可以监控线程执行情况。

1. 运行main线程，然后打开Terminal(左下角)，然后输入 JConsole(不区分大小写)打开工具。

2. 选择对应类的本地进程（可能有好多个，选第一个就行了）。

3. 选择不安全的连接。 

4. 这样可以看到，有main线程与Thread-0线程。 

对线程的理解 

 

  P587：经典多线程售票问题。到最后会出现票剩-2张等情况。这是因为各线程在判断是否票数为0时，基本上是同时判断的，因此可能票有1张，有三个线程，都认为票没卖完，又出售了三张，导致最后剩-2张。

线程终止

    所谓使用变量，其实就是用变量控制run方法的循环(比如t = true)，然后在main方法中对其进行修改。 

class AA implements Runnable{
    private boolean loop = true;  //控制run的进行
    @Override
    public void run() {
        while(loop){
            System.out.println("青眼白龙");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void setLoop(boolean loop) { //loop的Setter的方法
        this.loop = loop;
    }
}

    public static void main(String[] args) throws InterruptedException {
        AA aa = new AA();
        new Thread(aa).start(); //开启线程
        Thread.sleep(3000);
        aa.setLoop(false); //休息3秒后修改loop导致线程终止
    }

线程常用方法

注：这些都是Thread类的方法。

    有几个需要注意的点：1. start底层(start0)会创建新的线程调用run，run只是一个普通方法，不会启动新线程。 2. sleep是静态方法。3. 线程优先级的范围：

  4. 重点理解 interrupt 唤醒线程(注意不是中断线程！)：它并不会真正的结束线程，一般用于中断正在休眠的线程(相当于吵醒睡觉中的线程)。 InterruptedException就是用来接收 interrupt的。

class AA implements Runnable{
    private boolean loop = true;
    @Override
    public void run() {
        while(loop){
            System.out.println("青眼白龙");
            try {
                Thread.sleep(10000); //休眠10秒
            } catch (InterruptedException e) {//InterruptedException是捕获到一个中断异常
           //当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
                System.out.println(Thread.currentThread().getName() + "被interrupt了");
            }
        }
    }

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

 Thread.currentThread().getName()  获取当前线程名 

    public static void main(String[] args) throws InterruptedException {
        AA aa = new AA();
        Thread thread = new Thread(aa);
        thread.start();
        Thread.sleep(3000);
        thread.interrupt(); //主线程休息3秒后吵醒线程
    }

 

注：如果CPU资源充足，yield就不会成功，而join一旦调用，CPU就全力执行调用的线程，其它线程就停止了，所以一定成功。 

    public static void main(String[] args) throws InterruptedException {
        AA aa = new AA();
        Thread thread = new Thread(aa);
        thread.start();
        for(int i=0;i<100;i++){
            System.out.println("主线程执行第" + i +"次");
            if(i==10){
                thread.join();  //这时全力执行 aa对应的线程
            }
        }
    }

用户线程和守护线程

把一个线程设定成守护线程：  这样当其他用户线程都结束后，守护线程自动结束。

        AA aa = new AA();
        Thread thread = new Thread(aa);
        thread.setDaemon(true); //将子线程设置为守护线程

线程的状态

   原本线程的状态总共有六个，但是可以被细分成七个。 也就是 Runnable状态被分成了 Ready和Running两个状态。

Synchronized

线程同步机制简介

可以理解为某人进厕所后把门关上(上锁)，然后出来的时候剩下的人才能进去。 

售票问题的解决

class AA implements Runnable{
    public static int TicketNums = 100; //共享票数
    private boolean loop = true;
    public synchronized void sell(){ 
//把售票设为一个同步方法，这样每次只有一个线程访问
        if(TicketNums <=0){
            System.out.println("售票结束");
            loop = false; 
            return;
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        TicketNums--; //
        System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
         + " 剩余票数:" + TicketNums);
    }
    @Override
    public void run() {
        while(loop){ //持续贩卖
            sell();
        }
    }
}

    public static void main(String[] args) throws InterruptedException {
        AA aa = new AA();
        new Thread(aa).start(); 
        new Thread(aa).start();
        new Thread(aa).start(); //一个对象创造三个线程
}

互斥锁

    当一个方法设为synchronized，就相当于加了一把锁(如果锁在对象上那就是对象锁)，t1,t2,t3会争夺这把锁。

当一个线程争夺到时，锁会被打开，然后执行方法。

当方法执行完毕后，继续锁上，然后线程继续争抢。 

 public synchronized void sell() {}  就是一个同步方法，此时锁在this对象上。 

 当然也可以在代码块上写synchronize，同步代码块，互斥锁还是this对象。

 public void sell(){ 
    synchronized(this){  //同步代码块
        if(TicketNums <=0){
            System.out.println("售票结束");
            loop = false; 
            return;
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        TicketNums--; //
        System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
         + " 剩余票数:" + TicketNums);
    }
        
 }

5. 非静态同步方法的锁可以是当前对象，也可以是其它对象(要求是同一个对象，比如Object)。 

    Object object = new Object();
    AA aa = new AA();
    BB bb = new BB();
    public void sell(){
        synchronized (object){ //只有object可以，父类(bb)和自己(aa)都不行 
                               //多个线程访问同一个对象
            if(TicketNums <=0){
                System.out.println("售票结束");
                loop = false;
                return;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            TicketNums--;
            System.out.println("窗口 " + Thread.currentThread().getName() + 
               "售出一张票"  + " 剩余票数:" + TicketNums);
        }
    }

6. 静态的同步方法的锁为当前类本身。

    public static void m2(){
        synchronized (Test.class){ //不能写this了，要写 当前类名.class
            System.out.println("静态方法中的同步代码块");
        }
    }

 有一个重点要说明的： 多个线程的锁对象应为同一个！

synchronized (this){...} //同步代码块
public synchronized void sell(){...} //同步方法

    对于以上两种同步写法，所使用的对象都是this（也就是给this加了把锁），这样的写法对下面的主函数是有用的： 因为它们对应的都是一个对象，对应的方法也是同一个。

        AA aa = new AA();
        new Thread(aa).start(); 
        new Thread(aa).start();
        new Thread(aa).start(); //一个对象创造三个线程

  但是对于下面这种写法就不管用了：

        AA aa1 = new AA();
        AA aa2 = new AA();
        AA aa3 = new AA();
        new Thread(aa1).start();
        new Thread(aa2).start();
        new Thread(aa3).start();

   这里创建了三个不同的对象，因此它们的锁各管各的，相当于有三把锁，每个线程每次都能抢到锁。因此就不管用了。

线程死锁

比如： 妈妈：你先完成作业，才让你玩手机。  小明：你先让我玩手机，我才完成作业。

释放锁 

释放锁：从 线程调度器中出来（线程状态图的绿色块）就释放了锁，如果没有出来就是没有释放