java入门API_01之多线程下

线程同步-并发—B站秦疆老师
同一个对象被多个线程同时操作-----并发优先使用LOCK锁—去看lock
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时，我们据需要线程同步！
线程同步------> 其实 就是一种等待机制-----》多个需要同时访问此对象的线程进入“这个对象的等待池”形成队列，
等待前面的线程使用完毕，下一个线程才使用，，
线程同步形成的安全性条件：
队列和锁：在线程中，要保证安全就需要 队列 和锁，比如上厕所 ，有队列，排队上厕所，由门锁关门；
syn char nized --排它锁，独占资源，其他线程必须等待，使用后释放锁即可
存在问题：1、一个线程持有排它锁时，会使其他需要此锁的线程挂起；
2、在多线程竞争下，加锁释放锁会导致上下文 切换 和 调度延时，引起性能问题
3、若优先级高的A挂起等优先级低的B释放锁，会导致优先级倒置（低变高，高变低）引起性能问题

syn char nized的使用：
第一、修饰方法–控制 对 “对象”的访问，，方法执行，必须等方法全走完才能释放锁
缺点：若将大的方法加锁，会影响效率；
方法里边需要修改的内容才加锁，，锁的太多，浪费资源；
public synchronized void buy(){
//要加锁的内容
}
第二、代码块synchronized (obj) ===>obj也叫同步监视器
synchronized (this){//—（obj）this–锁的对象----推荐使用 共享资源作为同步监视器
要加锁的内容；
}
同步监视器的执行过程
1、第一个线程访问，锁定同步监视器，执行其代码
2、第二个线程访问，发现同步监视器被锁定，无法访问
3、第一个线程访问完毕，释放同步监视器；
4、第二个线程访问，发现同步监视器没锁，然后锁定访问；后续重复

线程通信—线程协作
这是个线程同步问题，生产者和消费者共享同一个资源，并且消费者和生产者之间相互依赖，互为条件（可判定条件）
生产者 消费者：
线程-》生产者-生产：没有生产产品之前，要通知消费者TT等待，而生产了产品（此时TT有产品）后，又需要马上通知消费者消费
中间缓冲区——》取餐台：TT— 数据缓冲区；
线程-》消费者-消费：在消费之后，要通知消费者，已经消费了（此时TT无产品），需要生产新的产品以共消费
在生产者消费者之间问题，仅有syncharnized是不够的：
syncharnized可以阻止并发更新同一个资源，实现同步
syncharnized不能用来实现不同线程之间的信息传递（通信）
java提供了几个方法解决线程之间的通信问题，，，—是OBJect类的方法—一下方法 只能在同步方法或同步代码块中使用

wait();/表示线程等待，知道其他线程通知， 与sleep不同，它会释放锁
wait(long timeout);//指定等待的毫秒数
notify();//唤醒一个处于等待状态的线程
notifyAll();//唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程优先调用；

解决方法：一、并发协作模型— 生产者消费者=====》管程法
生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
缓冲区：消费者不能直接使用生产者生产的数据，他们之间有个缓冲区
生产者将生产好的数据 放入缓冲区，消费者重缓冲区拿数据

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

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

    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            synContainer.pash(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer synContainer;

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

    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            System.out.println("消费了第"+synContainer.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
        int id;

    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer {
    //需要个容器大小
    Chicken[] c=new Chicken[100];
    //需要一个 计算器，，做条件
    int count=0;
    //生产者放入产品
    public synchronized  void  pash(Chicken chicken){
        //如果容器满了，就需要通知消费者消费
        if (count==c.length){
            //通知消费者，消费，生产者等待
            try {
                this.wait();//------------------------------------等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //生产者放入产品
            c[count]=chicken;
        count++;
        //可以通知消费者消费了
        this.notifyAll();//通知消费者 消费---------------------唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程优先调用；
    }
    //消费者消费
    public  synchronized  Chicken  pop(){
        //判断能否消费
        if (count==0){
          //等待生产者生产，消费者等待
            try {
                this.wait();//------------------------------------等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //可以消费
        count--;
        Chicken chicken = c[count];
        //通知生产者生产
        this.notifyAll();//通知生产线程 生产  ---------------------唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程优先调用；
        return chicken;
    }
}

二、并发协作模型— 生产者消费者=====》信号灯法-----标志位
使用一个标志位flag,如果为true ,就让它等待，如果不为就让它通知另外一个人；

package ks.Lambda;
//
public class TestPc2 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
//生产者--演员--只管演
class Player extends Thread{
    Tv tv;
    public Player(Tv tv) {
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (1/2==0){
                this.tv.play("春光灿烂猪八戒");
            }else {
                this.tv.play("抖音：记录美好生活");
            }
        }
    }
}
//消费者--观众--只管看
class Watcher extends Thread{
    Tv tv;
    public Watcher(Tv tv) {
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.tv.wach();
        }
    }
}
//产品--节目
class Tv{
    //逻辑：演员表演，观众等待 T
    //观众观看，演员等待  F
    String voice;//表演节目
    boolean flag=true;//--------------------------------------标志位
//表演：
    public  synchronized void play(String voice){
        if (!flag){
            try {
                this.wait();//---------------------------------------------等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了："+voice);
        //通知观众观看
       this.notifyAll();//---------------------------------------------通知运行
       this.voice=voice;//产品更新了
       this.flag=!this.flag;
    }
    //观看：
    public synchronized void wach(){
                if (flag){
                    try {
                        this.wait();//---------------------------------------------等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    System.out.println("正在观看。。看完了");
                    //通知演员表演
                    this.notifyAll();//---------------------------------------------通知运行
                    this.flag=!this.flag;
                }
    }
}

线程池 —jdk5提供了2个api
背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大；
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中；
可以避免频繁创建和销毁，实现重复利用；

核心好处：
1、提高响应速度（减少了创建新线程的时间）
2、降低资源消耗（重复使用线程池中的线程，不需要每次都创建）
3、便于线程管理
1-corePoolSize:核心池的大小
2-maximumPoolSize:最大线程数
3-KeepAliveTime:线程没有任务时最多保存多长时间后会终止
ExecutorService：-----真正的线程池接口（是接口故不能new，只能子类实现）
====》常见子类实现类–ThreadPool Executor
方法：void execute(Runnable command):执行任务/命令，无返回值，一般用来执行Runnable
Futuresubmit(Callabletask):执行任务，有返回值，一般执行callable
上边ExecutorService的实现类–》Executors: 工具类、线程池的工厂类，用于创建并返回不同类型的线程池
ExecutorService （接口） service= （实现类）Executors.newFixedThreadPool(10);

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//线程池
public class TestPool {
    public static void main(String[] args) {
        //创建服务，创建线程池
        //newFixedThreadPool线程池大小
        ExecutorService service=Executors.newFixedThreadPool(10);
        //执行
        service.execute(new myThread());
        service.execute(new myThread());
        service.execute(new myThread());
        service.execute(new myThread());
        service.shutdownNow();
    }

}

class myThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}