【java基础】关于线程的一些基础知识点

1.线程的概念：

在java的应用中，线程更多情况下指的是Thread，更精细一点，执行线程就是执行Thread实体下面的run方法，java通过cpu调试，交替进行这些thread，就达到了共同进行这种效果；

其中，main也被我们称作主线程。线程之间原则上是允许并行进行的，多线程就是同时在执行多个东西。

进程（process）包含多个线程，比如说打开视频算是一个进程，视频的音乐，画面，字幕和播放器支持都是线程（thread）

2.线程的具体实现和分析

线程的实现有三种方式

（1）Thread直接生成一个子类

首先建立一个类继承Thread，然后在这个类中重写run方法，run方法中就是你要执行的任务（线程），然后创建这个类的实体，最后实体使用start（）方法调用

public class threadOne extends Thread{
    public void run(){
        System.out.println("输出另一个线程");
    }
}

threadOne t=new threadOne();
       t.start();
        //main这里被称作主线程，而thread的run方法可以理解为另一个线程
        //另一个线程的调用方法为继承thread，重写run，创建对象，调用start

（2）实现Runnable接口，

首先也是创建一个类实现接口，类中重写run方法，然后创建类的实体，再用类的实体创建Thread类，最后再用start

public class threadRunable implements Runnable{
    public void run(){
        
    }
}

 threadRunable tr=new threadRunable();
        Thread a=new Thread(tr,"name");

Runnable实现的方式更为常用，他可以为一个类创建多个线程，并且可以给每个线程取名字

每个线程都是独立的，但是依托于同一个对象产生的线程，是共用这个类中的属性的，但是方法确实是自己在执行自己的

举个例子：

public class threadRunable implements Runnable{
    int a=10;
    public void run(){
        while(a>0){
            System.out.println(Thread.currentThread().getName()+a--);
        }
    }

    //这里注意一个问题，比如说我们有多个
}


        threadRunable tr=new threadRunable();
        Thread a=new Thread(tr,"a");
        Thread b=new Thread(tr,"b");
        Thread c=new Thread(tr,"c");
        Thread d=new Thread(tr,"d");
         a.start();b.start();c.start();d.start();

执行结果就是这样的

每个数字都会被一个线程读取一次，但是不会发生重叠

（3）利用callable接口实现的方法我们有机会再说 

3.线程的静态代理模式和lambda表达式

静态代理模式，其实通俗点讲就是，代理类和具体实现类实现了同一个接口

由代理类帮助具体类实现方法的过程，举个例子

为什么要说一句这个，因为这是Thread的底层原理

 然后我们常用的Runnable接口实现类构建Thread也是一种静态代理

大致原理和上面是一样的，具体有空再回来看看

其中Thread类的参数需要的是一个实现了 Runnable的类，其中这个接口被称作“函数式接口”，这种接口只有一个抽象方法，可以yonglambda的方式来创建匿名内部类

一般用接口创建匿名内部类的过程是这样的

 使用lambda表达式进行书写的话是这样的。类似箭头函数的写法（因为我们只需要实现一个抽象函数）

 4.线程的状态：

线程的状态一共有五种：

构建状态，阻塞状态，死亡状态，就绪状态，运行状态；具体类如截图所示

 （图片来自狂神大佬，感觉写的很明白了）

我们有一些方法让线程的状态发生一些人为的改变

Thread.sleep(int n);
//在线程运行的内部run方法中使用，可以让目前的线程动作进入阻塞状态n毫秒

 Thread.yield();
//线程礼让，让当前的线程重新回到就绪状态等待cpu调动


join（）;
//这个是在线程外，对具体的Thread对象使用
//使用以后强行让其他线程对象进入阻塞状态，直到本线程执行完
//相当于强行插队了


getState（）;
//获取当前线程状态，返回的是一个枚举类型

5.关于线程的同步

（1）同步的概念是，多个线程访问同一个资源，最典型的例子就是利用同一个Runable对象产生的多个线程。然后多个线程去访问同一个对象，这个对象可以是包含同步操作的”this“，也可以是外部指定的

（2）线程同步的安全性由两部分构成1.是不同线程的执行顺序（队列）2.在某个线程访问数据的时候，其他的线程不能访问（锁）（锁就有点类似于机组的关中断）

锁状态：每个对象都有一个锁状态，锁状态开放的时候，允许某个线程进行访问。锁状态关闭的时候，不允许其他线程进行访问。就类似厕所隔间，一个人进去了，其他人只能等这个人出来再想办法进去。

（3）线程不安全的处理方法为两个：synchronized方法，还有synchronized块

synchronized方法：修饰一个被线程执行时候使用的方法，当线程操作对象锁状态打开的时候，这个方法才能执行，否则等待锁打开再执行

举例子：

public class TestSafe implements Runnable{
    int num=10;
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
                //在线程执行的过程中会调用buy这个方法
                buy();//这一步最好包裹在try-catch里面
        }
    }

    //加了同步以后，就是让这个方法只有得到当前锁的时候才能执行，也就是说一次在执行的只能是一个方法
    //这时候，锁指的是this也就是当前对象的锁
    public synchronized void buy() throws InterruptedException {
        Thread.sleep(500);//线程休眠，问题就会放大
        if(num>0){
            System.out.println(Thread.currentThread().getName()+"买到了"+num--);
        }else{
            flag=false;
        }
    }

    public static void main(String[] args) {
        TestSafe a=new TestSafe();
        new Thread(a,"校长").start();
        new Thread(a,"教师").start();
        new Thread(a,"学生").start();
    }
}

还有synchronized块，这个准确来说是一种监视器，用来监视某个对象是否放开了锁，如果放开了就可以继续执行

class account{
    int sum=100;
    public void getter(int mon){
        this.sum-=mon;
    }
}
public class safeBlock implements Runnable{
    final account a=new account();
    @Override
    public void run() {
       synchronized (a){
           //监视的是这个线程中访问的对象
           //只有当前锁是开放的时候（没有线程在使用这个对象），才会对目前线程开放
           Thread.sleep(1000);
           if(a.sum>0){
                a.getter(10);
                System.out.println(Thread.currentThread().getName()+"-->"+10);
            }else{
                System.out.println(Thread.currentThread().getName()+"钱不够了");
            }

        }
    }

    public static void main(String[] args) {
        safeBlock sb=new safeBlock();
        new Thread(sb,"n").start();
        new Thread(sb,"22").start();
        new Thread(sb,"223").start();
    }
}

另外这里还有第三种手动开锁的方法：可重入锁Lock，本质上就是让当前的线程抱住目前访问对象的锁，和synchronzied（this）本质上是一样的

类名为ReentrantLock()，在上锁的时候lock方法，开锁的时候为unlock方法（另外只要注意的是，开锁一般放置在try-catch的finally块中，暂时不知道为了什么）

一个使用的案例如下

public class testLock {
    public static void main(String[] args) {
        hum h=new hum();
        new Thread(h,"小黄").start();
        new Thread(h,"小红").start();
        new Thread(h,"小王八羔子").start();
    }
}

class hum implements Runnable{
    int num=10;
    ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        //对当前的对象进行，线程去尝试抱有（锁住）
            while(true){
                try{
                    lock.lock();//手动上锁，当前的线程抱有这个对象的锁   //大约等价于synchronized (this) 
                        if (num > 0) {
                            try {
                                Thread.sleep(10000);
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            System.out.println(num-- + "-->" + Thread.currentThread().getName());
                        } else {
                            break;
                        }
                }finally {
                    lock.unlock();//手动解锁
                }

            }
    }
}

同步方法：线程抱住对象锁的时候才能执行（因为调用的时候通常会隐藏this）

同步块：尝试让当前线程抱住指定对象的锁空间

Lock类：让当前的线程，去给正在访问的对象上锁，然后手动开锁（相当于synchronized（this））

另外最后补充一点：死锁现象

死锁现象指的是，两个线程同时占用着对方需要的资源，就会僵持不下

下面这个代码假设两个人买东西，在同一时刻，两个人分别购买了葱和肉（两个线程分别先抱住A对象和B对象），然后接下来的过程中两人都需要彼此手中的东西（一个线程在抱住A的期间，想去抱住B，但是B的锁空间已经被占用了。。。。对方同理），就会构成死锁状态

代码解释

public void buy() throws InterruptedException {
        if(choice==0){
            synchronized (c){//该线程获取到对应对象的锁才会继续执行
                System.out.println(name+"买到了葱");
                Thread.sleep(1000);
                synchronized (m){
                    System.out.println(name+"买到了肉");
                }
            }
        }else{
            synchronized (m){
                System.out.println(name+"买到了肉");
                Thread.sleep(1000);
                synchronized (c){
                    System.out.println(name+"买到了葱");
                }
            }
        }
    }


//choice目的是区分两个线程