Java 多线程操作

以前一听到多线程操作就感到好腻害好腻害的，如果你现在也是这种情况或许这篇文章能够帮助到你。

1、什么是多线程？

先了解两个概念
进程：正在运行的程序，是系统进行资源分配和调用的独立单位，有自己的内存空间和系统资源。
线程：是进程中的单个顺序控制流，是一条执行路径，线程是应用程序中执行的基本单元。

某位大神的总结：进程就相当于工厂，线程就是工厂里的流水线，线程不能独立存在，必须存在于进程中。

多进程：系统中同时存在多个并行的进程，则称为多进程。可通过电脑任务管理器查看正在运行的进程，比如用电脑聊QQ的同时看电影，就是多进程的体现。
多线程：线程是进程中的单个顺序控制流，是一条执行路径，一个进程如果有多条执行路径，则称为多线程。比如给某人聊QQ的同时还可以接收到其他人的消息。

2、多线程实现方式

1.继承Thread类

Java提供了Thread类，让我们对线程进行操作。

    class MyThread extends Thread {    @Override    public void run() {        /* 多线程执行的逻辑 */        super.run();    }}    //开启线程    new MyThread().start();

2.实现Runable接口

   class MyRunnable implements Runnable {    @Override    public void run() {        /* 多线程执行的逻辑 */    }}  //将实现了Runnable接口的类，以参数的形式传递给Thread类  new Thread(new MyRunnable()).start();

3.实现Callable接口

这是一种有返回值的线程，但是必须通过线程池使用。

    public class Test {    public static void main(String[] args) {        // 生成线程池对象        ExecutorService pool = Executors.newCachedThreadPool();        // 提交Callable线程        pool.submit(new MyCallable());    }}   class MyCallable implements Callable<String> {    // 通过指定范型 可以通过线程方法返回该类型的数据 而其他两种实现方式都没有返回值    @Override    public String call() throws Exception {        /* 多线程执行的逻辑 */        return "hello";    }}

3、线程调度

分时调度模型 ：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片。
抢占式调度模型：抢占CPU使用权，其中优先级高的线程抢到CPU执行权的概率会越大，存在很大随机性。Java采用的是抢占式调度模型。

查看抢占式调度效果：

    public class Test {    public static void main(String[] args) throws InterruptedException {        // 生成线程对象        MyThread thread = new MyThread();        MyThread thread2 = new MyThread();        // 启动线程        thread.start();        thread2.start();        //第一次输出      //第二次输出        //Thread-0:0     //Thread-1:0        //Thread-1:0     //Thread-0:0        //Thread-1:1     //Thread-1:1        //Thread-1:2     //Thread-0:1        //Thread-0:1     //Thread-0:2        //Thread-0:2     //Thread-1:2    }}   // 线程类   class MyThread extends Thread {    @Override    public void run() {        for (int i = 0; i <3; i++) {            // 输出线程名和i的值            System.out.println(this.getName() + ":" + i);        }        super.run();    }}

通过输出可以看出线程抢占是随机的无规律可言（不设置优先级的情况下）。

如何设置线程优先级呢？

        //Thread提供了相关方法        // 设置线程的优先级        void setPriority(int newPriority)        // 返回线程的优先级        int getPriority()        // 生成线程对象        MyThread thread = new MyThread();        // 获取默认线程优先级        int priority = thread.getPriority();        System.out.println(priority);// 5        // 设置线程优先级        thread.setPriority(6);        // 输出最小线程优先级        System.out.println(thread.MIN_PRIORITY);// 1        // 输出最大线程优先级        System.out.println(thread.MAX_PRIORITY);// 10

可以看出线程的优先级的是1-10

4、线程控制

Thread类提供了相关方法对线程进行控制。

1.线程休眠sleep

    // 生成线程对象    MyThread thread = new MyThread();    //线程休眠3000毫秒    thread.sleep(3000);    //获取当前线程对象并设置其休眠200毫秒2000纳秒    Thread.currentThread().sleep(200, 2000);

2.线程加入join

        public static void main(String[] args) throws InterruptedException {        // 生成线程对象        MyThread thread = new MyThread("线程一");        MyThread thread2 = new MyThread("线程二");        // 启动线程        thread.start();        // 线程加入 当调用了线程加入了之后在该放后启动的线程会等这个线程执行完 在抢占CPU执行权        thread.join();        thread2.start();        //未添加前输出        //      线程一:0        //      线程一:1        //      线程二:0        //      线程一:2        //      线程二:1        //      线程二:2        //添加后输出        //      线程一:0        //      线程一:1        //      线程一:2        //      线程二:0        //      线程二:1        //      线程二:2    }}    // 线程类    class MyThread extends Thread {    public MyThread(String name) {        // 设置线程名        this.setName(name);    }    @Override    public void run() {        for (int i = 0; i < 3; i++) {            // 输出线程名和i的值            System.out.println(this.getName() + ":" + i);        }        super.run();    }}

3.线程礼让yield

        // 生成线程对象        MyThread thread = new MyThread("线程一");        MyThread thread2 = new MyThread("线程二");        //暂停当前正在执行的线程对象，并执行其他线程,让线程执行更和谐        thread.yield();        // 启动线程        thread.start();        thread2.start();        //输出        //      线程一:0        //      线程二:0        //      线程一:1        //      线程二:1        //      线程二:2        //      线程一:2

4.线程守护setDaemon

        // 生成线程对象        MyThread thread = new MyThread("线程一");        MyThread thread2 = new MyThread("线程二");        //将该线程标记为守护线程或用户线程  在启动线程前调用        //设置thread为守护线程   即当线程thread2执行完成后，如果thread未执行完则不再继续执行        //因为线程具有随机性，所以存在thread在thread2执行完的情况        thread.setDaemon(true);        // 启动线程        thread.start();        thread2.start();

5.线程中断stop、interrupt

        // 生成线程对象        MyThread thread = new MyThread("线程一");        MyThread thread2 = new MyThread("线程二");        // 启动线程        thread.start();        thread2.start();        // 立即终止某个线程，没有任何反馈，存在不安全性        //thread.stop();        // 中断线程        thread2.interrupt();        //输出：        //线程二线程终止！！！        //线程二------------        // 线程类        class MyThread extends Thread {            public MyThread(String name) {                // 设置线程名                this.setName(name);            }            @SuppressWarnings("static-access")            @Override            public void run() {                try {                    //当前线程休眠3秒                    this.sleep(3000);                } catch (InterruptedException e) {                    System.out.println(this.getName()+"线程终止！！！");                }                System.out.println(this.getName()+"------------");                super.run();            }        }

stop()方法会立刻终止线程并没有任何反馈，而interrupt()会有后续的输出。

5、线程生命周期

图示：

6、线程安全问题

1.线程安全问题

模拟卖票情况：两个线程对同一数据进行操作

    public class Test {    public static void main(String[] args) throws InterruptedException {        MyRunnable runnable = new MyRunnable();        new Thread(runnable, "卖票口一：").start();        new Thread(runnable, "卖票口二：").start();    }}    // 线程类    class MyRunnable implements Runnable {        private int ticket = 100;        @Override        public void run() {            // 多次执行            while (true) {                if (ticket > 0) {                    try {                        // 线程休眠模拟网络延迟                        Thread.sleep(300);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(Thread.currentThread().getName() + "正在出售第"+ ticket-- + "张票");                }            }        }    }

部分输出情况：

1.出现同票情况？根据输出可以推断，当ticket为40的时候，卖票窗口一线程抢到CPU执行权，并执行，但是执行run方法输出语句的时候， ticket–只执行完赋值操作并未执行–操作的时候，CPU执行权被卖票窗口二抢到，输出卖票窗口二：正在出售第40张票，然后卖票窗口一又抢到了CPU执行权输出卖票窗口一：正在出售第40张票。

2.出现0票情况？根据输出可以推断，当ticket为1的时候，卖票窗口一线程抢到CPU执行权，并执行，但是执行run方法未执行到输出语句的时候，CPU执行权并执行完run方法输出卖票窗口二：正在出售第1张票，然后卖票窗口一又抢到CPU执行权，此刻ticket已经为0了， 所以输出卖票窗口一：正在出售第0张票。

注：一般多线程环境、存在共享数据、多条语句操作共享数据的情况下会出现线程安全问题。那么如何解决呢？就用到了线程同步。

2.2.线程同步

1.同步代码块

 class MyRunnable implements Runnable {    private int ticket = 100;    @Override    public void run() {        // 多次执行        while (true) {            // 同步代码块（添加任意对象）            synchronized (this) {                if (ticket > 0) {                    try {                        // 线程休眠模拟网络延迟                        Thread.sleep(300);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(Thread.currentThread().getName()                            + "正在出售第" + ticket-- + "张票");                }            }        }    }}

注：同步代码块格式synchronized(对象){同步代码;}；同步可以解决安全问题的根本原因就在那个对象上，该对象就是锁，多个线程操作同一代码块，一定要保证那个锁对象相同。

2.同步方法

就是在方法上同步关键字。

  class MyRunnable implements Runnable {        private int ticket = 100;        @Override        public void run() {            // 多次执行            while (true) {                sellTicket();            }        }        /**         * 同步方法         */        private synchronized void sellTicket() {            if (ticket > 0) {                try {                    // 线程休眠模拟网络延迟                    Thread.sleep(300);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(Thread.currentThread().getName() + "正在出售第"                        + ticket-- + "张票");            }        }        /**         * 同步静态方法         */        private static synchronized void sellTicket() {            if (ticket > 0) {                try {                    // 线程休眠模拟网络延迟                    Thread.sleep(300);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(Thread.currentThread().getName() + "正在出售第"+ ticket-- + "张票");            }        }

注：同步方法的锁对象其实是当前对象this，同步静态方法的锁对象是当前类的字节码文件。

3.Lock锁的使用

JDK5提供了Lock锁接口，提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。

         // 获取锁         void lock()         // 释放锁         void unlock()

class MyRunnable implements Runnable {    private int ticket = 100;    //实现类对象实例化锁接口    Lock lock = new ReentrantLock();    @Override    public void run() {        // 多次执行        while (true) {            // 获取锁            lock.lock();            if (ticket > 0) {                try {                    // 线程休眠模拟网络延迟                    Thread.sleep(000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(Thread.currentThread().getName() + "正在出售第"                        + ticket-- + "张票");            }            // 释放锁            lock.unlock();        }    }

线程同步总结:

7、线程死锁问题

死锁就是线程间因相互等待对方资源，而不能继续执行的情况。线程同步嵌套就非常容易产生死锁问题。

修改之前的代码：

 class MyRunnable implements Runnable {    private int ticket = 100;    // 锁对象1    private Object object1 = new Object();    // 锁对象2    private Object object2 = new Object();    @Override    public void run() {        // 多次执行        while (true) {            if (ticket > 0) {                if (ticket % 2 == 0) {                    synchronized (object1) {// 这里出现线程死锁                        synchronized (object2) {                            System.out.println(Thread.currentThread().getName()                                    + "正在出售第" + ticket-- + "张票");                        }                    }                } else {                    synchronized (object2) {// 这里出现线程死锁                        synchronized (object1) {                            System.out.println(Thread.currentThread().getName()                                    + "正在出售第" + ticket-- + "张票");                        }                    }                }            }        }    }

该程序因为进行了同步嵌套所以会线程死锁问题，会出现输出不全的情况。

注：那么如何解决死锁问题呢？给资源排序，在所有的线程中，决定次序并始终遵照这个次序获取锁。

8、线程间通信问题

1.生产消费模式

多线程间除了线程安全问题外，还存在线程间通信问题。比如线程A执行完，操作了某些数据，而线程B需要这些数据做某些操作，这时线程A需要通知线程B已经有数据了，然后线程B做某些操作，当没有数据时线程B需要反馈给线程A。线程A和线程B之间就冥冥中存在了联系，这就是生成消费模式。
这个类似于Android中的Work线程和UI线程通过Handler通信一样，而java则提供了等待唤醒机制进行线程通信。

2.等待唤醒机制

Object类提供了notify、wait方法，对线程进行唤醒和等待。

    // 唤醒在此对象监视器上等待的单个线程    void notify()    // 唤醒在此对象监视器上等待的所有线程    void notifyAll()    // 在其他线程调用此对象的notify()方法或 notifyAll()方法前，导致当前线程等待    void wait()    // 在其他线程调用此对象的notify()方法或 notifyAll()方法，或者超过指定的时间量前，导致当前线程等待    void wait(long timeout)

    public class User {    String name;    int age;    boolean b = false;// 判断是否有数据    // 设置数据    public synchronized void setUser(String name, int age)            throws InterruptedException {        if (this.b) {            //如果存在数据就等待            // 线程等待            this.wait();        } else {            //没有数据则设置数据并唤醒某个线程            setName(name);            setAge(age);            this.b = true;            // 唤醒等待的单个线程            this.notify();        }    }    // 获取数据    public synchronized void getUser() throws InterruptedException {        if (this.b) {            // 相当于消费数据            System.out.println(getName() + "：" + getAge());            // 消费后相当资源消失            this.b = false;            // 唤醒线程            this.notify();        } else {            // 线程等待            this.wait();        }    }    /** 实现get set方法 **/}    public class Test {        public static void main(String[] args) throws InterruptedException {            User user = new User();            SetUserThread setUserThread = new SetUserThread(user);            GetUserThread getUserThread = new GetUserThread(user);            getUserThread.start();            setUserThread.start();        }    }    class GetUserThread extends Thread {        private User user;        public GetUserThread(User user) {            super();            this.user = user;        }        @Override        public void run() {            while (true) {                try {                    user.getUser();                } catch (InterruptedException e) {                    e.printStackTrace();                }                super.run();            }        }    }    class SetUserThread extends Thread {        private User user;        public SetUserThread(User user) {            super();            this.user = user;        }        @Override        public void run() {            while (true) {                try {                    user.setUser("Hello", 18);                } catch (InterruptedException e) {                    e.printStackTrace();                }                super.run();            }        }    }

9、线程组的使用

Java提供了线程组ThreadGroup对线程进行统一管理和调度。
ThreadGroup:线程组就是一个线程的集合。

        // 生成线程组对象，并设置名字        ThreadGroup threadGroup = new ThreadGroup("线程组一");        // 使用Thread的构造设置线程归宿的线程组        new Thread(threadGroup, new MyRunnable(), "线程一").start();        new Thread(threadGroup, new MyRunnable(), "线程二").start();        new Thread(threadGroup, new MyRunnable(), "线程三");        // 获取线程组名字        System.out.println(threadGroup.getName());// 线程组一        // 获取线程组活动线程的估计数        Thread[] threads = new Thread[threadGroup.activeCount()];        // 线程组中的所有活动线程复制到指定数组中        threadGroup.enumerate(threads);        System.out.println(threads.length);//运行多次输出 0 1 2        //通过输出可以看到 threadGroup.activeCount()结果所固有的不精确特性        // 中断线程组中所有线程        threadGroup.interrupt();

10、线程池的使用

线程池简述：开启一条线程是非常浪费资源的，因为它涉及到要与操作系统进行交互；因此JDK5之后Java提供了线程池让我们提高性能，线程池里的线程执行完后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。

相关对象
Executors：创建线程池的工厂类。

    创建方法：    // 创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们    static ExecutorService newCachedThreadPool()    // 创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程    static ExecutorService newFixedThreadPool(int nThreads)    // 创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的ThreadFactory创建新线程    static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)    // 创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程，在需要时使用提供的ThreadFactory创建新线程    static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)    // 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行    static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)    // 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行    static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)    //创建一个使用单个worker线程的Executor，以无界队列方式来运行该线程    public static ExecutorService newSingleThreadExecutor()

ExecutorService:线程池管理接口，提供了线程的操作方法。

    // 启动一次顺序关闭，执行以前提交的任务，但不接受新任务    void shutdown()    // 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表    List<Runnable> shutdownNow()    // 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future    <T> Future<T> submit(Callable<T> task)    // 提交一个 Runnable任务用于执行，并返回一个表示该任务的 Future    Future<?> submit(Runnable task)    // 提交一个 Runnable任务用于执行，并返回一个表示该任务的 Future    <T> Future<T> submit(Runnable task, T result)

        ExecutorService threadpool= Executors.newCachedThreadPool();        //提交任务        threadpool.submit(new Runnable() {            @Override            public void run() {                /**线程中执行逻辑**/            }        });        //这是实现线程的第三种方式        threadpool.submit(new Callable<String>() {            @Override            public String call() throws Exception {                /**线程中执行逻辑**/                return null;            }        });        //停止任务        threadpool.shutdown();

注：线程池可以很大程度上提高性能，如存在多线程环境建议使用 。

更多方法查看API