JavaSE之多线程再叙（3）（随笔）

多线程再叙（随笔）：

1.线程就是独立的执行路径
2.在程序运行时，即使没有自己创建线程，后台也会有多个线程，如：主线程(用户线程)、gc线程（垃圾回收线程）—（守护线程）
3.mian()称之为主线程，为系统的入口，用于执行整个程序
3.在一个进程中，如果开辟了多个线程，线程的运行由调度器（CPU）安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预。写程序时但能赋予不同线程的优先级。
4.对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
5.线程会带来额外的开销，如CPU调度时间，并发控制开销。
6.每个线程在自己工作内存交互，内存控制不当会造成数据不一致。
7.

8.礼让线程：

//礼让线程
public class ThreadYield {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        new Thread(myThread,"a").start();
        new Thread(myThread,"b").start();

    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        Thread.yield();//线程礼让-->看CPU心情，可能成功可能不成功
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}

9.守护线程：这里补个守护线程的程序

package com.atkong.javaSE.Multithreading2;

//守护线程
public class DaemonThread {
    public static void main(String[] args) {
        God god = new God();
        You1 you1 = new You1();

        Thread t1 = new Thread(god);
        Thread t2 = new Thread(you1);

        t1.setDaemon(true);//默认为false,正常的线程都是用户线程。此处将上帝线程设置为守护线程

        t1.start(); //守护线程God启动
        t2.start();//用户线程You启动

    }
}

//上帝
class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝一直守护着你!");
        }
    }
}

//你
class You1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("一生都快乐的活着！");
        }

        System.out.println("========goodbye world!==========");
    }
}

10.线程同步


11.线程协作（生产者消费者）：

//测试生产者消费者模型---》利用"缓冲区"解决："管程法"
//生产者，消费者，产品，缓冲区

public class ProducerAndConsumer {
    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 = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;//实例化一个容器
    //定义生产者构造方法
    public Consumer( SynContainer container) {
        this.container = container;
    }
    //消费
    @Override
    public void run() {
        for (int i = 0; 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 {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果容器没有满，我们就需要丢入产品
        chickens[count] = chicken;
        count++;
        //可以通知消费者消费了
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if (count == 0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];
        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;//返回吃了哪只鸡
    }

}

//测试生产者消费者问题2："信号灯法"，利用"标志位"解决
public class XinHaoDengMethod {
    public static void main(String[] args) {
        TV tv = new TV();

        new Player(tv).start();
        new Watcher(tv).start();

    }
}

//生产者--》演员
class Player extends Thread{
    TV tv = new TV();

    public Player( TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2 == 0){
                tv.play("快乐大本营播放中");
            }else {
                tv.play("抖音：记录美好生活！");
            }
        }
    }
}
//消费者--》观众
class Watcher extends Thread{
    TV tv = new TV();

    public Watcher( TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}
//产品--》节目
class TV{
    //演员表演，观众等待 True->标志位
    //观众观看，演员等待 False->标志位
    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 = !flag;
    }

    //观看
    public synchronized void watch(){
        //演员表演，观众等待
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了："+voice);

        //通知演员表演
        this.notifyAll();
        this.flag = !flag;
    }


}