复习JavaSE 10.多线程

并发：指两个或者多个事件在同一时间段同时发生例如cpu在多个线程中来回切换
并行：指两个或者多个事件在同一时刻发生单独一个cpu处理单独的线程一同进行
进程和线程的关系：
一个进程中可以有多个线程执行
锁只能监视由synchronized关键字内部或者由lock接口实现类包括的代码部分已实现同步或者通讯
相同锁之间才能实现通信

Java中程序属于抢占式调度方法运行程序

创建多线程方法 1：创建Thread子类重写run方法通过创建对象并调用start方法

public class CreateThread01 extends Thread {

    @Override
    public void run() {
        super.run();
        System.out.println(Thread.currentThread().getName());
        for (int n = 0; n <20; n++) {
            System.out.println("n====="+n);
        }
    }
}
class CreateThread01Test {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        new CreateThread01().start();
        for (int i = 0; i <20; i++) {
            System.out.println("i===="+i);
        }
    }
}

2:实现runnable接口并创建Thread对象将runnable作为参数传入Thread对象中
Runnable接口的好处：
1：避免了继承的局限性
一个类只能继承一个类实现runnable接口可以实现其他的类和接口
2：增强了程序的扩展性降低了程序的耦合度
把设置线程的任务和开启新线程进行分离(解耦)
重写run设置线程的任务
创建Thread 开启新线程

public class RunnableImpl01 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <10; i++) {
            System.out.println(Thread.currentThread().getName()+"  "+i);
        }
    }
}
class CreateThroad02{
    public static void main(String[] args) {
        RunnableImpl01 impl01 = new RunnableImpl01();
        new Thread(impl01).start();
        for (int i = 0; i <10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}

内部类形式创建线程

public class InnerThread {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <20; i++) {
                    System.out.println(Thread.currentThread().getName()+" "+i);
                }
            }
        }.start();
        new Thread(new Runnable() {
            @Override
            public void run() {

                for (int i = 0; i <20; i++) {
                    System.out.println(Thread.currentThread().getName()+" "+i);
                }
            }
        }).start();
        for (int i = 0; i <20; i++) {
            System.out.println(Thread.currentThread().getName()+"  "+i);
        }
    }
}

多线程共享数据可能产生安全问题

所以需要同步处理
同步代码块：
通过代码块的锁对象可以使用任意对象
但必须保证多个现成的锁对象是同一个
锁对象的作用：
把同步代码块锁住只让一个线程在同步代码块中执行

保证锁的唯一性所以锁的定义应该在run方法外部

  private int tacket = 100;
    Object object = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (object) {
                if (tacket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + 
                            "正在销售第 " + tacket + "张");
                    tacket--;
                }
            }
        }
    }

同步方法：
将共享数据封装在方法中方法用Synchronized修饰
同步方法的锁就是this
this就是实现runnable接口的实现类对象即this出现的本类对象
静态方法的锁对象是本类的class属性即class文件的对象

  private static int tacket = 100;
    @Override
    public void run() {
        while (true)
        methodDemo1();
    }
//锁就是this this就是 创建本类实例(实现类的对象)
//    静态同步方法因为优先于对象存在 所以锁就是本类的.class文件对象
    private static synchronized void methodDemo1() {
        if (tacket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在销售第 " + tacket + "张");
            tacket--;
        }
    }

Lock锁接口 1.5版本以后更灵活
在共享数据之前使用lock();方法在之后使用unlock();方法解锁
将unlock();放入finally中使用

public class SynchronizedLock implements Runnable {
    private int tacket = 100;
     Lock lock=new ReentrantLock();

    @Override
    public void run() {
        while (true) {
             lock.lock();
                if (tacket > 0) {
                    try {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + "正在销售第 " + tacket + "张");
                        tacket--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
//                        无论怎么样 最后一定要释放锁
                        lock.unlock();
                    }

                }

        }
    }
}

线程同步
wait notify保证了只有一个线程在执行一个线程等待另一个线程去唤醒
wait notify 一定要添加锁对象 (确定哪个锁之间的同步相互通信因为可能出现多个同步多个锁 )
保证同步中的多个线程进行等待或者唤醒
放在同步中保证同步的两个线程相互操作

public class ThreadWaitNotify {
    public static void main(String[] args) {
//        共享代码 锁对象
        Object o = new Object();
        new Thread() {
            @Override
            public void run() {
                synchronized (o) {
                    System.out.println("顾客吃包子告诉老板数量");
                    try {
                      o.wait();

                    } catch (InterruptedException e) {

                    }
                    System.out.println("吃了起来");
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
//                try {
//                    Thread.sleep(5000);

//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                synchronized (o) {
                    System.out.println("老板做包子");
                    o.notify();
                }
                System.out.println("做完包子 可以吃了");

            }
        }.start();
    }
}

等待唤醒机制说明
使用Object类的wait和notify方法
要求等待唤醒线程只能有一个线程在执行
使用同步方法
等待唤醒对应的锁应为同一个

实例吃包子做包子

创建一个类描述包子
包子有皮有馅能证明包子是否存在

创建两个线程类实现Runnable接口
1 包子铺类
如果包子存在则线程等待
如果包子不存在则制作包子
分别制作两种不同馅的包子
并唤醒吃包子的线程

2 吃包子线程
如果包子不存在则线程等待
如果包子存在则吃掉包子并换馅

创建测试类

public class Baozi {
    private String pi;
    public String[] xian={"白菜馅","猪肉馅"};
    public int  xianIndex=0;
    public boolean flog =false;

}

//包子铺类 生产包子
public class Baozipu implements Runnable {
    private Baozi baozi;

    public Baozipu(Baozi baozi) {
        this.baozi = baozi;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (baozi) {
                if (baozi.flog==true){
                    try {
                        baozi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    try {
                        Thread.sleep(1000);
                        String name = baozi.xian[baozi.xianIndex % 2];
                        System.out.println("生产了" + name + "的包子！");
                        baozi.flog = true;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        baozi.notify();
                    }

                }
            }
        }
    }
}

public class Chibaozi implements Runnable {

    private Baozi baozi;

    public Chibaozi(Baozi baozi) {

        this.baozi = baozi;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (baozi) {
                if (baozi.flog==false) {
                    try {
                        baozi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    String name = baozi.xian[baozi.xianIndex % 2];
                    baozi.xianIndex++;
                    try {
                        Thread.sleep(1000);
                        System.out.println("我吃到了" + name + "的包子");
                        baozi.flog = false;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        baozi.notify();
                    }
                }
            }
        }
    }
}

public class BaoziTest {
    public static void main(String[] args) {
        Baozi baozi = new Baozi();
       new Thread(new Baozipu(baozi)).start();
       new Thread(new Chibaozi(baozi)).start();

    }
}

线程池

降低资源消耗不需要重复创建线程
提高了响应速度

java.util.concurrent.Executors 线程工厂
static ExecutorService newFixedThreadPool(int nThreads)
创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。
ExecutorService方法 Future<?> submit(Runnable task)
提交一个可运行的任务执行，并返回一个表示该任务的未来。

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        threadPool.submit(new RunnableImpl());
        //pool-1-thread-1正在执行
        threadPool.submit(new RunnableImpl());
        threadPool.submit(new RunnableImpl());
        threadPool.submit(new RunnableImpl());
        //pool-1-thread-4正在执行
        //pool-1-thread-3正在执行
        //pool-1-thread-1正在执行
        //pool-1-thread-2正在执行

//        销毁线程池 不建议使用
        threadPool.shutdown();
    }
}

最后编辑于：2019.03.13 08:20:14

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 213,254评论 6赞 492
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,875评论 3赞 387
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 158,682评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,896评论 1赞 285
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,015评论 6赞 385
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,152评论 1赞 291
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,208评论 3赞 412
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,962评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,388评论 1赞 304
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,700评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,867评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,551评论 4赞 335
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,186评论 3赞 317
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,901评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,142评论 1赞 267
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,689评论 2赞 362
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,757评论 2赞 351

复习JavaSE 10.多线程

推荐阅读更多精彩内容