java并发编程实战 显示锁 java并发线程代码

一、背景

多线程能够在操作系统多核配置的基础上，更好的利用服务器多个CPU资源。Java通过对多线程的支持来在一个进程内并发执行多个线程，每个线程都并行执行不同的任务。

二、线程创建方式

一共四种方式：继承Thread类、实现Runnable接口、ExecutorService和Call<Class>（有返回Class类型值）、基于线程池方式。

1、继承Thread类

Thread类实现了Runnable接口并定义了操作线程的一些方法。具体使用方式，创建一个类并继承Thread接口，然后实例化线程对象并调用start()方法启动线程，start方法是navite方法。代码如下

private static class ThreadTest extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread" + i);
            }
        }
    }

    /**
     * 线程概念：一个程序里不同的执行路径
     *
     * @param args
     */
    public static void main(String[] args) {
        //实例化对象
        ThreadTest threadTest = new ThreadTest();
        //线程启动
        threadTest.start();

    }

2、实现Runnable接口

Java由于是单继承，子类已经继承了一个类，就无法继承Thread类，Java提供了Runnable接口创建线程，代码如下：

private static class ThreadTestRunnable implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Runnable" + i);
            }
        }
    }
    public static void main(String[] args) {
     Thread thread=  new Thread(new ThreadTestRunnable());
     thread.start();
    }

3、ExcutorService和Callable<Class>实现有返回值的线程

场景主线程中开启多个线程并发执行一个任务，然后把各个线程执行的返回结果汇总起来，这时候需要用到Callable接口。
具体步骤，创建一个类并实现Callable接口，在call方法中实现具体的运算逻辑并返回结果，使用线程池提交任务，并把结果保存在Future中，添加到一个FutureList中，最后遍历FutureList，通过Future的实例get()方法可获取Callable线程任务的返回结果，具体实现如下。

/**
     * 自定义Callable接口
     */
    private static class MyCallable implements Callable<String> {
        private String name;

        //通过构造函数为线程传递参数，定义线程的名称
        public MyCallable(String name) {
            this.name = name;
        }
        
        @Override
        public String call() throws Exception {
            //逻辑处理
            System.out.println("正在执行的线程："+name);
            return name;
        }
    }

    public static void main(String[] args) {
        //创建固定大小5线程池
        ExecutorService pool = Executors.newFixedThreadPool(5);
        List<Future> futureList = new ArrayList<Future>();
        for (int i = 0; i < 5; i++) {
            Callable callable = new MyCallable(i + "");
            //提交线程池执行
            Future future = pool.submit(callable);
            futureList.add(future);
        }
        //关闭线程池
        pool.shutdown();
        //遍历结果
        futureList.forEach(f -> {
            try {
                System.out.println(f.get().toString());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });
    }

4、线程池方式

创建并在运行结束后销毁是非常浪费资源的，可以使用缓存策略并使用线程池来创建线程。
具体步骤：创建一个线程池，并使用该线程池提交线程任务，代码如下。

//定长线程池
        ExecutorService pool= Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            pool.execute(()->{
                System.out.println(Thread.currentThread().getName()+"  is Running");
            });
        }
        //关闭线程池
        pool.shutdown();