多线程学习

process进程

thread 线程

程序是一个静态的，当程序运行起来就变成进程，进程里包含至少一个线程

线程创建方式

1.继承thread类   2.实现Runnable接口(主要） 3.实现Callable接口

实现Runnable接口(主要）

 龟兔赛跑

静态代理模式

代理类和被代理类都要实现同一个接口

模板：

new 代理类（new 被代理类）.接口中重写的方法

lambda表达式

函数式接口：接口中只包含唯一一个抽象方法

简化掉：new iLike(){public void lambda  xxxxxxxxxx}  除xxx部分以外都不要 

 线程停止

 

sleep应用 

 每个对象都有一把锁，sleep不会释放锁

线程礼让yield（让当前正在执行的线程暂停，但不阻塞）

本质：让CPU重新调度，礼让不一定成功，看CPU心情

线程强制执行join（插队）

少使用，会使线程堵塞

线程优先级Priority

可以设置1-10的优先级

 先设置后启动

守护线程deamon 

线程分为用户线程和守护线程

thread.setDeamon(true);  默认为false表示为守护线程

线程同步

直接加synchronized（相当于上厕所时有一个有锁的门，需要排队一个个进入）

修改的方法才需要添加，读取的方法不用

同步块 

 

死锁解决方式

一个线程同一时间只能拥有一把锁（要等待第一个锁释放后再去获得第二个锁）

A获得口红       B获得镜子

A释放口红      B释放镜子

A获得镜子     B获得口红

 lock锁

sleep不会释放锁   

wait会释放锁       notifyAll()作用：唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

管程法

//生产者 消费者 缓冲区
public class shengchanxiaofei {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Productor(synContainer).start();
        new Consumer(synContainer).start();

    }
}
class Productor extends Thread{
    SynContainer container;

    public Productor(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {

            System.out.println("生产了第"+i+"只鸡");
            container.push(new Chicken(i));
        }
    }
}
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("消费了第"+container.pop().id+"只鸡");
        }
    }
}
class Chicken{
    int id;
    public Chicken(int id) {
        this.id = id;
    }
}
class SynContainer{
    Chicken[] chickens=new Chicken[10];
    int count=0;
    public synchronized void push(Chicken chicken){
        if (count==chickens.length){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        chickens[count]=chicken;
        count++;
        notifyAll();
    }
    public synchronized Chicken pop(){
        if(count==0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken=chickens[count];
        notifyAll();
        return chicken;
    }
}

信号灯法

 

 

 

 

线程池

ExecutorService：真正的线程池接口

Executor ：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

Runnable接口 创建线程池

Callable接口 创建线程池