Java高并发(二)——多线程基础

朴灿烈づ我的快乐病毒、 2022-04-16 06:38 206阅读 0赞

在上一篇 [JAVA高并发——了解并行世界][JAVA] 中我们回顾了一些多线程的概念知识。这里先举个例子，来看现实生活中的多线程例子：一个家庭中有爸爸、妈妈、儿子，家中有电视、洗衣机、书桌等，如果妈妈领着儿子出去了，爸爸就可以想干什么干什么（单线程）；如果三人都在家，妈妈可以洗衣服、爸爸在书桌上工作、儿子看动画片（三个线程使用不同的资源互不影响）；如果儿子看动画片，爸爸想看NBA视频，就得等着儿子看完了（多线程公用资源，出现阻塞）……看见了吧，其实我们就是把程序编写的如何像现实生活一样，多个任务同时进行，有共享资源，有各自资源，但是大家能够有条不紊的进行着……

好，这篇我们来复习一下Java多线程的一些基础知识，来看下这张思维导图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWppYWhhbjYyOTYyOQ_size_16_color_FFFFFF_t_70][]

一，首先需要了解线程的状态有哪些，怎么扭转，其实也就是生命周期（现实生活做事也是可以这样抽象）。我先看下Java，Thread类中对于state的定义：

public enum State {
            /**
             * Thread state for a thread which has not yet started.
             */
            NEW,
    
            /**
             * Thread state for a runnable thread.  A thread in the runnable
             * state is executing in the Java virtual machine but it may
             * be waiting for other resources from the operating system
             * such as processor.
             */
            RUNNABLE,
    
            /**
             * Thread state for a thread blocked waiting for a monitor lock.
             * A thread in the blocked state is waiting for a monitor lock
             * to enter a synchronized block/method or
             * reenter a synchronized block/method after calling
             * {@link Object#wait() Object.wait}.
             */
            BLOCKED,
    
            /**
             * Thread state for a waiting thread.
             * A thread is in the waiting state due to calling one of the
             * following methods:
             * <ul>
             *   <li>{@link Object#wait() Object.wait} with no timeout</li>
             *   <li>{@link #join() Thread.join} with no timeout</li>
             *   <li>{@link LockSupport#park() LockSupport.park}</li>
             * </ul>
             *
             * <p>A thread in the waiting state is waiting for another thread to
             * perform a particular action.
             *
             * For example, a thread that has called <tt>Object.wait()</tt>
             * on an object is waiting for another thread to call
             * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
             * that object. A thread that has called <tt>Thread.join()</tt>
             * is waiting for a specified thread to terminate.
             */
            WAITING,
    
            /**
             * Thread state for a waiting thread with a specified waiting time.
             * A thread is in the timed waiting state due to calling one of
             * the following methods with a specified positive waiting time:
             * <ul>
             *   <li>{@link #sleep Thread.sleep}</li>
             *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
             *   <li>{@link #join(long) Thread.join} with timeout</li>
             *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
             *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
             * </ul>
             */
            TIMED_WAITING,
    
            /**
             * Thread state for a terminated thread.
             * The thread has completed execution.
             */
            TERMINATED;
        }

好，看下这几种状态的相互转化吧：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWppYWhhbjYyOTYyOQ_size_16_color_FFFFFF_t_70 1][]

二，接下来看下线程的基本操作：

1，新建线程：这个不用说了，通过继承Thread或者实现Runnable接口两种方式。

2，终止线程：一般来说，线程执行完毕就会结束，无须自动关闭。但是对于一些while true的线程如果想关闭呢？Thread类里有stop()方法，但是已经不建议使用了。因为它是强制停止线程，无论线程处于什么状态，很容易出现线程正在处理一半数据被停止的情况，这样非常容易造成数据不一致问题。所以慎用stop()(最好不用)，通过下边这种方式来停止哪些无限循环的线程：

public class StopThread extends Thread {
    
        volatile boolean stopme = false;
    
        //停止方法
        public void stopMe() {
            stopme = true;
        }
    
        @Override
        public void run() {
            while (true) {
                //死循环中如果出现停止标识，则直接跳出
                if (stopme) {
                    System.out.println("exit by stop me");
                    break;
                }
    
                System.out.println(System.currentTimeMillis());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

3，线程中断：是一种线程协作机制。是告诉目标线程一个中断通知，至于接到通知后如何处理，则有线程自己决定处理。

public class InterruptThread {
    
    
        /**
         * public void interrupt() 中断线程
         * public static boolean interrupted() 判断是否被中断，并清除当前中断标识
         * public boolean isInterrupted() 判断是否被中断
         */
        public static void main(String[] args) throws InterruptedException {
    
            Thread t1 = new Thread() {
                @Override
                public void run() {
                    while (true) {
                        //判断如果有中断标识，则直接跳出
                        if (Thread.currentThread().isInterrupted()) {
                            System.out.println("exit by interrupted");
                            break;
                        }
    
                        System.out.println(System.currentTimeMillis());
                        Thread.yield();
                    }
                }
            };
    
            t1.start();
            Thread.sleep(2000);
            //打上中断标识
            t1.interrupt();
        }
    }

4，等待（wait）和通知（notify），也是为了支持线程之间的协作。方法都是在Object上定义的，例如线程A调用了obj.wiat()方法，那么线程A就会停止执行，等到其它线程调用obj.notify()方法为止。

public class WaitNotifyThread {
        final static Object ob = new Object();
    
        public static class T1 extends Thread {
            @Override
            public void run() {
                synchronized (ob) {
                    System.out.println(System.currentTimeMillis() + "t1 is start");
    
                    try {
                        System.out.println(System.currentTimeMillis() + "t1 is wait");
                        ob.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(System.currentTimeMillis() + "t1 is end");
    
                }
            }
        }
    
    
        public static class T2 extends Thread {
            @Override
            public void run() {
                synchronized (ob) {
                    System.out.println(System.currentTimeMillis() + "t2 is start");
    
    
                    System.out.println(System.currentTimeMillis() + "t2 is notify start");
                    ob.notify();
                    System.out.println(System.currentTimeMillis() + "t2 is notify end");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(System.currentTimeMillis() + "t2 is end");
    
                }
            }
        }
    
        public static void main(String[] args) {
            Thread t1 = new T1();
            Thread t2 = new T2();
            t1.start();
            t2.start();
        }
    }

5，挂起（suspend）和继续执行（resume）：也是一对相对的操作，但是JDK也已经标示为废弃方法，不推荐使用。应为使用suspend（）去挂起导致线程暂停的同时，并不释放资源，会阻塞其它线程，如果处理不当（例如resume()处理在suspend()之前了，就会导致一直阻塞），所以慎用。我们可以通过wait和notify来像实现stopMe()一样，实现自己一个挂起和继续执行操作。这里不再演示。

6，等待线程结束（join）和谦让（yield）：类似现实生活中，我做这件事得等着它做完那件事，我为他让让步等。很容易理解的：

public class JoinThread {
        volatile static int i = 0;
    
        public static  class AddThread extends Thread{
            @Override
            public void run() {
                for(i=0;i<10000;i++);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            AddThread addThread = new AddThread();
            addThread.start();
            //主线程等待addTread执行完毕
            addThread.join();
            System.out.println(i);
        }
    }

三，volatile：非常重要的关键字，如果用volatile修饰，虚拟机就会特殊处理，不能随意变动优化目标指令；并且修改后，各个线程都能看见它的改动，保证变量的可见性。在那个中共享变量是“一写多读”的情况下非常使用，保证修改及时可见。

四，线程组：非常容易理解的概念，如果线程过多，为了方便管理，有了线程组，简单看下使用：

public class ThreadGroupTest implements Runnable {
        public void run() {
            String groupName = Thread.currentThread().getThreadGroup().getName() + "--" + Thread.currentThread().getName();
            while (true){
                System.out.println(" i am " + groupName);
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) {
            ThreadGroup threadGroup = new ThreadGroup("testGroup");
            Thread t1 = new Thread(threadGroup,new ThreadGroupTest(),"T1");
            Thread t2 = new Thread(threadGroup,new ThreadGroupTest(),"T2");
            t1.start();
            t2.start();
            System.out.println(threadGroup.activeCount());
            threadGroup.list();
        }
    }

五，守护线程（Daemon）:是一种特殊的线程，听名字猜想这种线程是系统的守护者。例如jvm的垃圾回收线程等。当一个Java应用中只有守护线程时，也就会自然退出：

public class DaemonDome {
    
        public static class T1 extends Thread {
            @Override
            public void run() {
                while (true) {
                    System.out.println(" i am live");
    
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread t = new T1();
            t.setDaemon(true);
            t.start();
    
            Thread.sleep(2000);
        }
    }

六，线程优先级，这个比较好理解，优先级从1到10数字越大优先级越高，只是说概率更高而已，而并非一定。Tread提供三个静态变量：

/**
         * The minimum priority that a thread can have.
         */
        public final static int MIN_PRIORITY = 1;
    
       /**
         * The default priority that is assigned to a thread.
         */
        public final static int NORM_PRIORITY = 5;
    
        /**
         * The maximum priority that a thread can have.
         */
        public final static int MAX_PRIORITY = 10;

七，线程安全和synchronized：线程安全就是针对共享资源能够高效有序的使用，不要出现同时修改，最终导致数据不一致的问题。而共享资源的同步使用即可解决。synchronized的作用就是实现线程间的同步。前边已经用到，我们不在看例子，总结一下它的用法：**1，指定加锁对象**：给对象加锁，进入同步代码前要获得给定对象的锁：synchronized（obj）；**2，直接作用于实例方法**：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁：synchronized（this）；**3，直接作用于静态方法**：相当于当前类加锁，进入同步代码前要获得当前类的锁。

好，高并发——Java多线程的复习总结就这样，还是说结合实际生活来学习联想。接下来，我们会继续……

[JAVA]: https://blog.csdn.net/liujiahan629629/article/details/84039097
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWppYWhhbjYyOTYyOQ_size_16_color_FFFFFF_t_70]: /images/20220416/5d63084f560f488bb67bf901760a4c33.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWppYWhhbjYyOTYyOQ_size_16_color_FFFFFF_t_70 1]: /images/20220416/5aff5bc4b91748dcbcfa868003be37a6.png