Java多线程自我小结

一、多线程（Thread）的相关概念

1. 进程

• 指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

2. 线程

• 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
• 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

3. 线程调度

（1）分时调度

• 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

（2）抢占式调度

• 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
• CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高。

4. 同步与异步

• 同步:排队执行 , 效率低但是安全.
• 异步:同时执行 , 效率高但是数据不安全.

5. 并发与并行

• 并发：指两个或多个事件在同一个时间段内发生，比如并发量就是指在一段时间内发生的数量。
• 并行：指两个或多个事件在同一时刻发生（同时发生）。

二、多线程的三种启动方式

1. 直接通过继承Thread启动

public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
class MyThread extends Thread{
    /**
     * run方法就是线程要执行的任务方法
     */
    @Override
    public void run() {
        //这里的代码，就是一条新的执行路径
        //这个执行路径的触发方式，不是调用run方法，而是通过thread对象的start()方法来启动任务
        for (int i = 0; i < 10; i++) {
            System.out.println("橙小狮"+i);
        }
    }
}

2. 通过实现Runnable接口给线程分配任务启动

public static void main(String[] args) {
        //实现Runnable
        //1.        创建一个任务对象
        MyRunnable r = new MyRunnable();
        //2.        创建一个线程，并为其分配一个任务
        Thread t = new Thread(r);
        //3.        执行这个线程
        t.start();
    }
class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("田小主"+i);
        }
    }
}

实现Runnable 与 继承Thread相比有如下优势：
* 1. 通过创建任务，然后给线程分配任务进行执行的方式来实现的多线程，更适合多个线程同时执行相同任务的情况
* 2. 可以避免单继承所带来的局限性
* 3. 任务与线程本身是分离的，提高了程序的健壮性
* 4. 且在线程池技术中，接受Runnable类型的任务，不接受Thread类型的线程

3. 通过实现带返回值的Callable接口给线程分配任务启动

public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(c);
        new Thread(task).start();
        task.isDone();
        Integer result = task.get();
        System.out.println("\nMyCallable的返回值为："+result);
    }
    static class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 10; i++) {
                Thread.sleep(100);
                System.out.print(i+"  ");
            }
            return 100;
        }
    }

Runnable 与 Callable的 相同点 :
-----1.都是接口
-----2.都可以编写多线程程序
-----3.都采用Thread.start()启动线程
Runnable 与 Callable的 不同点 :
-----Runnable没有返回值；Callable可以返回执行结果
-----Callable接口的call()允许抛出异常；Runnable的run()不能抛出
Callable可以获取返回值
-----Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

三、线程的六种状态

状态	解释
NEW	尚未启动的线程的线程状态
WAITING	等待线程的线程状态
BLOCKED	线程的线程状态被阻塞等待监视器锁定
RUNNABL	可运行线程的线程状态
TERMINATED	终止线程的线程状态
TIMED_WAITING	具有指定等待时间的等待线程的线程状态

1. 读取文件、用户输入等也是线程阻塞
2. 所有比较消耗时间的操作都是线程阻塞（耗时操作）

四、线程的常用方法

1. 设置和获取当前线程名称

	Thread.currentThread().getName();

2. 使当前线程休眠

	Thread.sleep(1000,1000);

3. 给线程添加中断标记，使线程合理中断

	new Threa().interrupt();

	public static void main(String[] args) {
        //线程中断
        /**
         * 一个线程是一个独立的执行路径，它是否应该结束，应该由其自身决定
         * （所有资源进行及时的释放）
         * 打标记来中断线程
         */
        Thread t1 = new Thread(new MyRunnable());
        t1.start();

        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }
        }
        //给线程1添加中断标记
        t1.interrupt();
    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("发现了中断标记，完成相应操作，释放资源后线程自杀");
                    //进行需要的操作和完成资源的释放
                    return;
                }
            }
        }
    }

4. 标记当前线程为守护线程

	Thread.sleep(1000,1000);

	/**
     *  线程： 分为守护线程和 用户线程
     *  用户线程：当一个进程不包含任何的存活的用户线程时，进程结束
     *  守护线程：守护用户线程，当最后一个用户线程结束时，所有守护线程自动死亡
     *
     *
     * @param args
     */
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.setDaemon(true);
        t1.start();

        for (int i = 0; i < 5; i++) {

            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }
            if (i==4)
                System.out.println("用户线程执行结束");
        }
    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
    }

五、线程安全问题及三种解决方案

1. 线程安全问题病因

1. 两个及以上线程共享某个资源
2. 两个及以上线程都在修改相同资源数据（包括数据库数据等）

2. 三种解决方案

（1）同步代码块

 /**
     * 线程同步：synchronized
     * 任何对象都可以打上锁标记
     * @param args
     */
    public static void main(String[] args) {
        //线程不安全
        //解决方案1：同步代码块
        //格式：synchronized(锁对象){}
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //票数
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            while (true){
                synchronized (o){
                    if (count>0) {
                        //卖票
                        System.out.println("正在准备卖票：");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            //                    e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+" 出票成功，余票为" + count);
                    }else {
                        break;
                    }
                }

            }
        }
    }

（2）同步方法

    public static void main(String[] args) {
        //线程不安全
        //解决方案2：同步方法
        //格式：synchronized(锁对象){}
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            while (true){
                boolean flag = sale();
                if (!flag){
                    break;
                }
            }
        }
        //同步方法
        public synchronized boolean sale(){
            if (count>0) {
                //卖票
                System.out.println("正在准备卖票：");
                /*try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //                    e.printStackTrace();
                }*/
                count--;
                System.out.println(Thread.currentThread().getName()+" 出票成功，余票为" + count);
                return true;
            }
            return false;
        }
    }

（3）显示锁Lock

/**
     * 同步代码块 和 同步方法  属于隐式锁
     * 线程同步：Lock
     */
    public static void main(String[] args) {
        //线程不安全
        //解决方案3：显示锁Lock
        //格式：synchronized(锁对象){}
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 10;
        //显示锁 l : fair参数为true   就表示公平锁
        Lock l = new ReentrantLock(true);
        @Override
        public void run() {
            while (true){
                if (count>0) {
                    //卖票
                    System.out.println("正在准备卖票：");
                    l.lock();
                    count--;
                    l.unlock();
                    System.out.println(Thread.currentThread().getName()+" 出票成功，余票为" + count);
                }else {
                    break;
                }
            }
        }
    }

3. 线程死锁

• 线程死锁 ：当两线程同时持有某一资源又同时需要对方资源时，这个时候线程持续运行，导致线程阻塞，产生线程死锁
• 避免死锁的方法：当进程本身拥有一个锁时，尽量避免另一个锁的产生

    public static void main(String[] args) {
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();
        c.say(p);
    }
    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        public MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }
        @Override
        public void run() {
            p.say(c);
        }
    }
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
            p.answer();
        }
        public synchronized void answer(){
            System.out.println("罪犯被放走了，罪犯也放了人质");
        }
    }
    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放了人质，我放了你");
            c.answer();
        }
        public synchronized void answer(){
            /*try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
//                e.printStackTrace();
            }*/
            System.out.println("警察把罪犯放走了，警察救出了人质");
        }
    }

4. 多线程通信问题

	//  多线程通信问题，生产者和消费者
    //  通过线程的唤醒和等待来避免线程数据的紊乱
    public static void main(String[] args) {
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }
    //厨师
    static class Cook extends Thread{
        private Food f;
        public Cook(Food f){
            this.f = f;
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                if (i%2==0){
                    f.setNameAndTaste("黄焖鸡","香辣味");
                }else {
                    f.setNameAndTaste("过桥米线","豚骨味");
                }
            }
        }
    }
    //服务生
    static class Waiter extends Thread{
        private Food f;
        public Waiter(Food f){
            this.f = f;
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
//                e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;
        //
        private boolean flag = true;

        public synchronized void setNameAndTaste(String name,String taste){
            if (flag){
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
//                e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
            if (!flag){
                System.out.println("服务生端走的饭菜的名称"+name+",味道："+taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

六、线程池（Executors）

1. 线程池概述

• 创建线程 -> 创建任务 ->执行任务 ->关闭线程（创建和关闭线程花费大量的时间）
• 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

2. 线程池的好处

• 降低资源消耗。
• 提高响应速度。
• 提高线程的可管理性。

3. 四种线程池

（1）缓存线程池（CachedThreadPool）

/**
     *  缓存线程池
     *  （长度无限制）
     *  任务加入后的执行流程：
     *          1.  判断线程池是否存在空闲线程
     *          2.  存在则使用
     *          3.  不存在，则创建线程，并放入线程池，然后使用
     */

public static void main(String[] args) {
        //向线程池中加入新的任务
        ExecutorService service = Executors.newCachedThreadPool();
        //指挥线程池执行新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 执行线程池中新添加的任务1");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 执行线程池中新添加的任务2");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 执行线程池中新添加的任务3");
            }
        });
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 执行线程池中新添加的任务4");
            }
        });
    }

（2）定长线程池（FixedThreadPool）

/**
     *  定长线程池
     *  （长度是指定的数值）
     *  任务加入后的执行流程：
     *      1.  判断线程池是否存在空闲线程
     *      2.  存在则使用
     *      3.  不存在空闲线程，且线程池未满的情况下，则创建线程，并放入线程池，然后使用
     *      4.  不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程
     */

public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"定长线程池执行任务1");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"定长线程池执行任务2");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"定长线程池执行任务3");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

（3）单线程线程池（SingleThreadExecutor）

/**
     *  单线程线程池
     *  执行流程：
     *      1.      判断线程池  的那个线程  是否空闲
     *      2.      空闲则使用
     *      3.      不空闲，则等待  池中的单个线程空闲后  使用
     */

public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+":单线程线程池");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+":单线程线程池");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+":单线程线程池");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

    }

（4）周期定长线程池（ScheduledThreadPool）

/**
     *  周期任务    定长线程池
     *  执行流程：
     *      1.      判断线程池是否存在空闲线程
     *      2.      存在则使用
     *      3.      不存在空闲线程，且线程池未满的情况下，则创建线程  并放入线程，然后使用
     *      4.      不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程
     *
     *  周期性任务执行时：
     *          定时执行，当某个时机触发时，自动执行某任务
     */

public static void main(String[] args) {
        ScheduledExecutorService s = Executors.newScheduledThreadPool(2);
        /**
         * 1.   定时执行一次
         *      参数1.    定时执行的任务
         *      参数2.    时长数字
         *      参数3.    时长数字的时间单位  ， TimeUnit的常量指定
         */
        /*s.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("周期定长线程池定时5秒后执行一次且总共一次");
            }
        },5, TimeUnit.SECONDS);*/
        /**
         *  周期性执行任务
         *      参数
         */
        s.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("周期定长线程池定时5秒后执行一次，之后每间隔3秒执行一次");
            }
        },5,3,TimeUnit.SECONDS);
    }

4. Lambda表达式（优化线程写法）

/**
     *  Lambda表达式
     *  函数式编程思想
     *      面向对象：   创建对象调用方法  解决问题
     */

    public static void main(String[] args) {
        //冗余的Runnable代码
//        MyRunnable runnable = new MyRunnable();
//        Thread thread = new Thread(runnable);
//        thread.start();
        //简化之后仍然冗余
        /*Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("简化之后仍然冗余严重");
            }
        });
        t.start();*/
        //运用Lambda表达式后
        Thread thread = new Thread(() -> System.out.println("运用Lambda表达式后的代码"));
        thread.start();

        //额外举一个例子
        print(new MyMath() {
            @Override
            public int sum(int x, int y) {
                return x+y;
            }
        },1000,9009);

        print((int x,int y) -> {return x+y;},1000,9009 );

    }


    /*static class MyRunnable implements Runnable{

        @Override
        public void run() {
            System.out.println("冗余的代码");
        }
    }*/

    public static void print(MyMath m,int x,int y){
        int num = m.sum(x,y);
        System.out.println(num);
    }

    interface MyMath{
        int sum(int x,int y);
    }