复习JavaSE 10.多线程

2019-03-08 本文已影响0人第二套广播体操

并发：指两个或者多个事件在同一时间段同时发生例如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();
    }
}

复习JavaSE 10.多线程

猜你喜欢

热点阅读