Java之多线程

1，多线程的作用:

线程是程序执行的一条路径, 一个进程中可以包含多条线程，多线程并发执行可以提高程序的效率, 可以同时完成多项工作

1.1，多线程的应用场景:

• 红蜘蛛同时共享屏幕给多个电脑
• 迅雷开启多条线程一起下载
• QQ同时和多个人一起视频
• 服务器同时处理多个客户端请求
• 读取超大文件时

1.2，线程并发与并行的区别：

区别:
　　并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
　　并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
简单释义:
　　如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。
　　比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。

1.3，线程的生命周期:

• 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();
• 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；
• 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就 绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
• 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种
  • 等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
  • 同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
  • 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
• 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

2，线程的三种创建方式：

2.1，继承Thread类：

public class Demo01_Thread {
    public static void main(String[] args) {
        MyThread mh = new MyThread();    //4.创建Thread类的子类对象
        mh.start();                        //5.开启线程
    }
}
class MyThread extends Thread{                //1.继承Thread
    @Override
    public void run() {                        //2.重写run方法
        for (int i = 0; i < 10000; i++) {    //3.将要执行的代码写在run方法中
            System.out.println(getName+"继承线程已执行"+i);
        }
    }
}

如上代码所示，创建MyThread实例进入新建状态，然后调用start（）方法启动，但是线程不一定会立马启动，因为要看cpu的资源分配

2.2，实现Runnable:

public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();    //4.创建Runnable中的子类实例
        Thread tr = new Thread(mr);    //将Runnable中的子类变量放入Thread类中
        tr.start();
    }
}
class MyRunnable implements Runnable{    //1.定义类实现Runnable

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {    //2.重写Run方法
            System.out.println(Thread.currentThread().getName()+"Runnable中的线程执行:"+i);    //3.将要执行代码写在run方法中
        }
    }
}

• 源码的区别:
  • 继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
  • 实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
• 总结的优点与弊端:
  • 继承Thread：
    • 优点:可以直接使用Thread类中的方法,代码简单
    • 弊端:如果已经有了父类,就不能用这种方法
  • 实现Runnable接口:
    • 优点:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
    • 弊端:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

2.3，实现Callable创建线程:

    // 创建线程池对象
    ExecutorService pool = Executors.newFixedThreadPool(2);

    // 可以执行Runnable对象或者Callable对象代表的线程
    Future<Integer> f1 = pool.submit(new MyCallable(100));
    Future<Integer> f2 = pool.submit(new MyCallable(200));

    // V get()
    Integer i1 = f1.get();
    Integer i2 = f2.get();

    System.out.println(i1);
    System.out.println(i2);

    // 结束
    pool.shutdown();

    public class MyCallable implements Callable<Integer> {

        private int number;

        public MyCallable(int num