java-初识多线程(1)

Thread And Runnable

Thread和Runnable是在java中比较简单的多线程实现方式，也是早期的多线程相关的API。例如：

public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
                    public void run() {
                        System.out.printf("[Thread: %s]Hello,world ....\n",
                                Thread.currentThread().getName());
                    }
                },"Child");
        thread.start();
        System.out.printf("[Thread: %s]Hello,world ....\n",
                Thread.currentThread().getName());

    }

上述例子中，可以实现多线程的程序。但是提出如下疑问：

• 不支持原生的完成回调
• 缺少锁的API
• 执行结果获取困难

J.U.C并发框架

在Java 5.0 提供了 java.util.concurrent(简称JUC)包。提供了多种并发的编程模型和并发容器(ConcurrentHashMap)等等。引入了Executor、Runnable、Callable、Future的编程模型。
如下线程池例子：

public static void main(String[] args) {
        Executor executor
                 = Executors.newCachedThreadPool();
        //执行器，线程池是一种实现
        executor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.printf("[Thread: %s]Hello,world ....\n",
                        Thread.currentThread().getName());
            }
        });
        //合理地关闭线程池是非常重要的
        if(executor instanceof ExecutorService){
            ExecutorService executorService = ExecutorService.class.cast(executor);
            executorService.shutdown();
        }

        //java5 开始实施AutoCloseable ，IO,JDBC但是不包括线程池
    }

使用线程池可以减少创建和销毁线程的消耗，复用线程，提高效率。

Future例子

public static void main(String[] args) throws ExecutionException, InterruptedException {
        //执行器服务
        ExecutorService executorService
                = Executors.newCachedThreadPool();
        //异步操作 等待操作   类似join 等待线程去"死"
       Future<String> future =  executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {

                return "[Thread: "+Thread.currentThread().getName()
                        +"]Hello,world ....\n";

            }
        });

       //阻塞了线程或者发生错误，会抛出异常
       //get() 使用了join来实现，会阻塞当前线程
       String value  = future.get();
       System.out.println(value);
       executorService.shutdown();
       System.out.println("线程运行结束");
    }

使用Future可以在完成之后获得返回结果。

Fork/Join

在java7中，java提出了并行框架Fork/Join

并发与并行是两个既相似而又不相同的概念：并发性，又称共行性，是指能处理多个同时性活动的能力；并行是指同时发生的两个并发事件，具有并发的含义，而并发则不一定并行，也亦是说并发事件之间不一定要同一时刻发生

例如：

public static void main(String[] args) {

        //于ThreadExecutor 类似
        ForkJoinPool forkJoinPool  = new ForkJoinPool();
        forkJoinPool.invoke(new RecursiveAction() {
            @Override
            protected void compute() {
                System.out.printf("[Thread: %s]Hello,world ....\n",
                        Thread.currentThread().getName());
            }
        });

        forkJoinPool.shutdown();

    }

Fork/Join 异步并行框架

在java8中，Fork/Join是异步并行框架。例子如下：

public static void main(String[] args) throws ExecutionException, InterruptedException {

        //合并操作
        //支持链式写法，处理异常，异步的处理返回结果
        CompletableFuture asyncompletableFuture =CompletableFuture.supplyAsync(() ->{
            //获取数据操作，假设来自于数据库
            return String.format("[Thread: "+Thread.currentThread().getName()
                    +"]Hello,world ....");
        }).thenApply(value -> {
            return value+"-----来自于数据库";
        }).thenApply(value ->{
            return value + LocalDate.now();
        }).thenApply(value ->{
            return value;
        }).thenAccept(value ->{
            System.out.println(value);
        }).thenRun( () ->{
            System.out.println("commit ---操作结束");
        }); 
        while (!asyncompletableFuture.isDone()){

        }


        System.out.println("start。。。。");

    }

由于，对于并发这块，刚刚学习，不能讲的很清楚什么是什么，暂时放上API的调用例子，后续会一直跟进学习。