多线程的学习：基础1

B站**遇见狂神说**的视频，博客是我做的笔记，强烈推荐这个up
https://space.bilibili.com/95256449?spm_id_from=333.788.b_765f7570696e666f.2
这是他B站空间地址

线程实现

线程状态

线程同步

线程通信问题 wait notify 锁

实现线程的三种方式：1. 继承Thread类，2.实现Runnable接口 3.实现Collable接口 4. 设计线程池
####################################
静态代理的思想： WedDing 和 You 都实现Marry接口； you 传递给 WedDing,实现you可以实现不仅仅自身的方法

new Thread( ()->{ xxxxxxxx} ).strat() 就是这种思想
总结： 真实对象和代理对象实现同一个接口，代理对象要代理真实角色

####################################
Lambda 表达式
1. 避免内部匿名类定义过多
2. 可以让代码看起来更简洁
3. 去掉一堆没意义的代码 只留下核心的逻辑

 函数式接口： Functuional Interface
 任何接口，如果只包含唯一一个抽象的方法，那么他就是一个函数式接口
 对于函数式接口，可以通过Lambda来创建改接口的对象

匿名内部类：没有类的名称，必须借用父类或者接口
like = new ILike() {
    @Override
    public void lambda() {

    }
}
Lambda 表达式：
like = () -> { ...... }

####################################
线程的5大状态
创建-就绪-运行-阻塞-死亡

1.线程停止
不推荐使用JDK自带的stop或者destroy方法
推荐使用 通过中间变量去跳出线程。

2. 线程休眠
   sleep方法 会有异常

3.线程礼让
礼让不一定成功，看CPU心情

//礼让不一定成功，完全看CPU心情
public class Thread_yield {
    public static void main(String[] args) {
        Myyield myyield = new Myyield();
        new Thread(myyield,"a").start();
        new Thread(myyield,"b").start();
    }
}
class Myyield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

join就是插队，该线程插队，别的线程阻塞

################################
线程状态

通过Thread.State state = thread.getState();获取线程状态

#####################################
线程优先级

优先级高的不一定先执行，也有CPU调度的因素，但是权重会高，大多情况会按照优先级的顺序执行

thread.setDaemon(true) 默认是false是用户线程（正常的线程）

![在这里插入图片描述](https://img-blog.csdnimg.cn/a7cc0e011d0b4d43a40c6ee63cec3268.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5byA5Y-R6ICF55CD55CD,size_20,color_FFFFFF,t_70,g_se,x_16

队列+锁 保证线程安全，

#####################################
不安全账户的代码
两个线程可能同时操作account里面的信息，所以会有线程不安全的现象
解决办法就是 用synchronized (account) 把共享的这个量锁住，从而使线程排队操作这个量

package com.pq.multiThread.syn;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing girlfriend = new Drawing(account,80,"你老婆");
        you.start();
        girlfriend.start();
    }
}
class Account {
    int money;
    String name;
    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
class Drawing extends Thread {
    Account account ;
    int drawingmoney;
    int nowmoney;
    public Drawing(Account account,int drawingMoney,String name) {
        this.account = account;
        this.drawingmoney = drawingMoney;
    }

    @Override
    public void run() {

        if ( account.money - drawingmoney <0) {
            System.out.println(this.getName()+" money is not enough");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money = account.money - drawingmoney;
//        nowmoney = nowmoney + drawingmoney;
        System.out.println(account.name +"余额为：" + account.money);

    }
}

最后的结果

解决不安全的代码：

    @Override
    public void run() {
        synchronized (account) {
            if ( account.money - drawingmoney <0) {
                System.out.println(this.getName()+" money is not enough");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money = account.money - drawingmoney;
            System.out.println(account.name +"余额为：" + account.money);

        }

    }

锁住的对象就是 ： 共享的，变化的量
#######################################
死锁
多个线程相互拥有对方需要的资源，然后形成僵持

Lock

```java
package com.pq.multiThread.Lock;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.*;

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock = new TestLock2();

        new Thread(testLock,"A").start();
        new Thread(testLock,"B").start();
        new Thread(testLock,"C").start();

    }
}
class TestLock2 implements Runnable {

    int ticketNum = 100;
    ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true) {
            try {
                lock.lock();
                if (ticketNum > 0) {

                    System.out.println(Thread.currentThread().getName()+"剩余票数量："+ticketNum--);
                }
            } finally {
                lock.unlock();
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}