多线程的应用与原理分析1

╰半夏微凉° 2022-03-25 11:56 203阅读 0赞

> **文章最前**： 我是Octopus，这个名字来源于我的中文名--章鱼；我热爱编程、热爱算法、热爱开源。所有源码在我的个人[github][] ；这博客是记录我学习的点点滴滴，如果您对 Python、Java、AI、算法有兴趣，可以关注我的动态，一起学习，共同进步。

**相关文章：**

1.  [多线程的应用与原理分析1][1]
2.  [多线程的应用与原理分析2（线程的状态）][2]
3.  [多线程的应用与原理分析3（原子性、可见性、有序性）][3]
4.  [多线程的应用与原理分析4（synchronized）][4_synchronized]
5.  [多线程的应用与原理分析5（ReentrantLock）][5_ReentrantLock]
6.  [多线程的应用与原理分析6（ReentrantLock）][6_ReentrantLock]
7.  [多线程的应用与原理分析7（Condition）][7_Condition]
8.  [多线程的应用与原理分析8（countdownlatch）][8_countdownlatch]
9.  [多线程的应用与原理分析9（原子操作）][9]
10. [多线程的应用与原理分析10（Semaphore）][10_Semaphore]
11. [多线程的应用与原理分析11（线程池）][11]

--------------------

1.多线程最终解决的就是“等待”问题，它的简单使用场景：

1）通过并行计算提高程序执行性能；

2）需要等待网络，1/0响应导致耗费大量的执行时间，可以采用异步线程的方式减少阻塞；

2.tomcat7以前的io模型

**多线程的应用场景**

1）客户端阻塞：如果客户端只有一个线程，这个线程发起读取文件的操作必须等到IO流返回，线程（客户端）才能做其他的事

2）线程级别阻塞BIO：客户端一个线程情况下，导致整个客户端阻塞；

可以使用多线程，一部分线程在等待IO操作返回其他线程可以继续做其他的事；此时从客户端角度来说，客户端没有闲着。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p5MzQ1MjkzNzIx_size_16_color_FFFFFF_t_70][]

如何使用多线程？

在java中，有多种方式来实现多线程，继承Thread类，实现Runnable接口，使用ExecutorService，Callable，Future实现带返回值结果的多线程。

1）继承thread创建线程

Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start方法，start是一个native方法，它会启动一个新线程，并执行run方法，这种方式实现多线程很简单，通过自己的类直接extend thread,并覆写run方法，就可以启动新线程并执行自己定义的run方法。

package lock;
    
    /**
     * @author zhangyu
     * @version V1.0
     * @ClassName: MyThread
     * @Description: 继承Thread类
     * @date 2019/1/19 19:04
     **/
    
    
    public class MyThread extends Thread {
        public void run() {
            System.out.println("my thread run");
        }
    
        public static void main(String[] args) {
            MyThread thread1 = new MyThread();
            MyThread thread2 = new MyThread();
            thread1.start();
            thread2.start();
        }
    }

**2）实现Runnable接口创建线程**

如果已经继承了一个类，就无法继承Thread了，此时可以实现一个Runnable的接口；

package lock;
    
    /**
     * @author zhangyu
     * @version V1.0
     * @ClassName: MyThread2
     * @Description: 实现runnable接口
     * @date 2019/1/19 19:07
     **/
    
    
    public class MyThread2 implements Runnable {
        @Override
        public void run() {
            System.out.println("myThread2 run");
        }
    
        public static void main(String[] args) {
            MyThread2 myThread1 = new MyThread2();
            MyThread2 myThread2 = new MyThread2();
            Thread t1 = new Thread(myThread1);
            Thread t2 = new Thread(myThread2);
            t1.start();
            t2.start();
        }
    }

3）实现Callable接口通过FutureTask包装器来创建Thread线程

有时，我们需要让一步执行的线程在执行完成以后，提供一个返回值给到当前的主线程，主线程需要依赖这个值进行后续的逻辑处理，那么这个时候，就需要带返回值的线程。

package lock.callable;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    /**
     * @author zhangyu
     * @version V1.0
     * @ClassName: CallableDemo
     * @Description: 带返回值的多线程
     * @date 2019/1/19 19:10
     **/
    
    
    public class CallableDemo implements Callable<String> {
        @Override
        public String call() throws Exception {
            int a = 1;
            int b = 2;
            System.out.println(a + b);
            return "执行结果:" + (a + b);
        }
    
        public static void main(String[] args) throws Exception {
            ExecutorService executorService = Executors.newFixedThreadPool(1);
            CallableDemo callableDemo = new CallableDemo();
            Future<String> future = executorService.submit(callableDemo);
            System.out.println(future.get());
            executorService.shutdown();
        }
    }

线程使用的更优雅：

合理利用异步操作，大大提升程序的处理性能，zookeeper中就是通过阻塞队列以及多线程的方式，实现对请求的异步化处理，提升性能：

1.Request.java

package lock.demo;
    
    /**
     * @author zhangyu
     * @version V1.0
     * @ClassName: Request
     * @Description: 请求的bean
     * @date 2019/1/19 19:16
     **/
    
    
    public class Request {
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String toString() {
            return "request{" + "name=" + name + "\'" + '}';
        }
    }

2.RequestProcessor.java

package lock.demo;
    
    /**
     * @author zhangyu
     * @version V1.0
     * @ClassName: RequestProcessor
     * @Description: 接口
     * @date 2019/1/19 19:18
     **/
    
    
    public interface RequestProcessor {
        void processRequest(Request request);
    }

3.PrintProcessor.java

package lock.demo;
    
    import java.util.concurrent.LinkedBlockingQueue;
    
    /**
     * @author zhangyu
     * @version V1.0
     * @ClassName: PrintProcessor
     * @Description: TOTO
     * @date 2019/1/19 19:19
     **/
    
    
    public class PrintProcessor extends Thread implements RequestProcessor {
        LinkedBlockingQueue<Request> requests = new LinkedBlockingQueue<>();
        private final RequestProcessor nextProcessor;
    
        public PrintProcessor(RequestProcessor nextProcessor) {
            this.nextProcessor = nextProcessor;
        }
    
        public void run() {
            while (true) {
                try {
                    Request request = requests.take();
                    System.out.println("pring data:" + request.getName());
                    nextProcessor.processRequest(request);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        //进行处理请求
        @Override
        public void processRequest(Request request) {
            requests.add(request);
        }
    }

4.SaveProcessor.java

package lock.demo;
    
    import java.util.concurrent.LinkedBlockingQueue;
    
    /**
     * @author zhangyu
     * @version V1.0
     * @ClassName: SaveProcessor
     * @Description: 保存信息
     * @date 2019/1/19 19:24
     **/
    
    
    public class SaveProcessor extends Thread implements RequestProcessor {
        LinkedBlockingQueue<Request> requests = new LinkedBlockingQueue<>();
    
        public void run() {
            while (true) {
                try {
                    Request request = requests.take();
                    System.out.println("begin save request info:" + request);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        // 处理请求
        @Override
        public void processRequest(Request request) {
            requests.add(request);
        }
    }

5.Demo.java

package lock.demo;
    
    /**
     * @author zhangyu
     * @version V1.0
     * @ClassName: Demo
     * @Description: 测试
     * @date 2019/1/19 19:27
     **/
    
    
    public class Demo {
        PrintProcessor printProcessor;
    
        protected Demo() {
            SaveProcessor saveProcessor = new SaveProcessor();
            saveProcessor.start();
            printProcessor = new PrintProcessor(saveProcessor);
            printProcessor.start();
        }
    
        private void doTest(Request request) {
            printProcessor.processRequest(request);
        }
    
        public static void main(String[] args) {
            Request request = new Request();
            request.setName("zhangyu");
            new Demo().doTest(request);
        }
    }

[github]: https://github.com/zhangyu345293721
[1]: https://blog.csdn.net/zy345293721/article/details/86565631
[2]: https://blog.csdn.net/zy345293721/article/details/86583663
[3]: https://blog.csdn.net/zy345293721/article/details/86596268
[4_synchronized]: https://blog.csdn.net/zy345293721/article/details/86607632
[5_ReentrantLock]: https://blog.csdn.net/zy345293721/article/details/86617801
[6_ReentrantLock]: https://blog.csdn.net/zy345293721/article/details/86621392
[7_Condition]: https://blog.csdn.net/zy345293721/article/details/86622891
[8_countdownlatch]: https://blog.csdn.net/zy345293721/article/details/86636846
[9]: https://blog.csdn.net/zy345293721/article/details/86645245
[10_Semaphore]: https://blog.csdn.net/zy345293721/article/details/86644996
[11]: https://blog.csdn.net/zy345293721/article/details/86646019
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p5MzQ1MjkzNzIx_size_16_color_FFFFFF_t_70]: /images/20220325/2d1e2c50cf40448dbf572d1d7cc745c6.png