Java并发编程|第一篇：线程初体验

系列文章

• Java并发编程|第一篇：线程初体验
• Java并发编程|第二篇：线程生命周期
• Java并发编程|第三篇：synchronized锁
• Java并发编程|第四篇：synchronized锁升级
• Java并发编程|第五篇：可见性，java内存模型
• Java并发编程|第六篇：ReentrantLock 重入锁
• Java并发编程|第七篇：Condition
• Java并发编程|第八篇：CountDownLatch
• Java并发编程|第九篇：Semaphore 信号量
• 持续更新中…

1. java中如何使用线程

• 1.Runnable接口
• 2.Thread类（本质上也是实现Runnable接口）
• 3.Callable/Future带返回值的线程
• 4.线程池ThreadPool

2. 线程作用

线程可以合理利用多核心CPU资源，提高程序的吞吐量

3.Thread类本质上也是实现Runnable接口

jdk源码 Thread实现了Runnable接口

重写了run()方法

target其实是我们传入的对象
测试代码：

public class App extends Thread {

    @Override
    public void run() {
        System.out.println("running!!!!");
    }

    public static void main(String[] args) {
     new Thread(new App()).start();
    }
}

测试结果：

4.实际例子

4.1预设场景：request请求处理

request请求的处理逻辑如下：

• 1.预处理
• 2.打印
• 3.保存

整条链路是串行的处理逻辑
但是在每个链节点上的处理使用多线程的方式+队列的方式异步化进行处理了，从而提高程序的性能

4.2 代码

处理类设计逻辑：

• 使用LinkedBlockingQueue来做异步队列的处理
• 使用责任链模式来完成流程的处理
• 继承Thread类，重写run方法，在run方法中nextProcessor.process(take);调用下一个链的节点进行处理

4.2.1 request

request对象

public class Request {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "Request{" +
                "name='" + name + '\'' +
                '}';
    }
}

4.2.2 IRequestProcessor

处理request请求统一接口

public interface IRequestProcessor {
    void process(Request request);
}

4.2.3 PrevProcessor

预处理类

import java.util.concurrent.LinkedBlockingQueue;

public class PrevProcessor extends Thread implements IRequestProcessor {

    //阻塞队列 消息异步处理
    LinkedBlockingQueue<Request> requests = new LinkedBlockingQueue();

    private IRequestProcessor nextProcessor;

    private volatile boolean isFinish = false;

    public PrevProcessor(IRequestProcessor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }

    public PrevProcessor() {
    }

    public void shutDwon() {
        isFinish = true;
    }

    @Override
    public void run() {
        while (!isFinish) {
            try {
                Request take = requests.take();
                System.out.println("PrevProcess" + take);
                nextProcessor.process(take);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void process(Request request) {
        //根据实际需求做处理
        requests.add(request);
    }
}

4.2.4 PrintProcessor

 import java.util.concurrent.LinkedBlockingQueue;

public class PrintProcessor extends Thread implements IRequestProcessor {
    //阻塞队列 消息异步处理
    LinkedBlockingQueue<Request> requests = new LinkedBlockingQueue();

    private IRequestProcessor nextProcessor;

    private volatile boolean isFinish = false;

    public PrintProcessor(IRequestProcessor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }

    public PrintProcessor() {
    }

    public void shutDwon() {
        isFinish = true;
    }

    @Override
    public void run() {
        while (!isFinish) {
            try {
                Request take = requests.take();
                System.out.println("PrintProcess" + take);
                if (null != nextProcessor) {
                    nextProcessor.process(take);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void process(Request request) {
        //根据实际需求做处理
        requests.add(request);
    }
    
}

4.2.5 SaveProcessor

import java.util.concurrent.LinkedBlockingQueue;

public class SaveProcessor extends Thread implements IRequestProcessor {
    //阻塞队列 消息异步处理
    LinkedBlockingQueue<Request> requests = new LinkedBlockingQueue();

    private IRequestProcessor nextProcessor;

    private volatile boolean isFinish = false;

    public SaveProcessor(IRequestProcessor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }

    public SaveProcessor() {
    }

    public void shutDwon() {
        isFinish = true;
    }

    @Override
    public void run() {
        while (!isFinish) {
            try {
                Request take = requests.take();
                System.out.println("SaveProcessor" + take);
                if (null != nextProcessor) {
                    nextProcessor.process(take);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void process(Request request) {
        //根据实际需求做处理
        requests.add(request);
    }
}

4.2.6 测试调用

public class Test {

    static IRequestProcessor requestProcessor;

     public void setUp() {
        SaveProcessor saveProcessor = new SaveProcessor();
        saveProcessor.start();
        PrintProcessor printProcessor = new PrintProcessor(saveProcessor);
        printProcessor.start();
        requestProcessor = new PrevProcessor(printProcessor);
        ((PrevProcessor) requestProcessor).start();
    }

    public static void main(String[] args) {

        Test test = new Test();
        test.setUp();
        Request request = new Request();
        request.setName("xwf");

        requestProcessor.process(request);

    }


}

结果：

5.参考

腾讯课堂->咕泡学院->mic老师->并发编程基础

6.系列链接

下一篇:Java并发编程|第二篇：线程生命周期