线城池

package chapter5;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
 
import javax.swing.plaf.ListUI;
 
/**
 * 除了 new Thread() 之外所有都是阻塞方法
 * @author fenglei.ma 2018/01/15
 */
public class FutureTaskMain {
 
    /**
     *  FutureTask 单任务  方式一
     */
    public static void main1(String args[]) throws Exception {
//      Executors.newCachedThreadPool()
        ExecutorService executorService = Executors.newFixedThreadPool(1);
 
        // 构造FutureTask
        FutureTask<String> futureTask = new FutureTask<String>(new RealData2("a"));
 
        executorService.submit(futureTask);
 
        System.out.println("请求完毕");
 
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // 取得call()方法的返回值 如果此时get方法没有执行完成,则依然会等待
        System.out.println("数据=" + futureTask.get());
        System.out.println("执行完了");
 
        executorService.shutdown();
    }
     
    /**
     * FutureTask submit 多任务  方式二
     */
    public static void main2(String args[]) throws Exception {
        long starttime = System.currentTimeMillis();
        Integer total_task = 0;
        ExecutorService executorService = Executors.newFixedThreadPool(10);
         
        List<FutureTask<String>> list = new ArrayList<FutureTask<String> >();
        for(int i=1; i<6 ;i++){
            FutureTask<String> futureTask = new FutureTask<String>(new RealData2("a"+i));
            executorService.submit(futureTask);
             
            list.add(futureTask);
            total_task ++;
        }
 
        System.out.println("请求完毕");
 
        TimeUnit.MILLISECONDS.sleep(2);
 
        for(int i=0 ;i<total_task;i++){
            // 取得call()方法的返回值 如果此时get方法没有执行完成,则依然会等待,知道所有都返回结果
            System.out.println("数据=" +  list.get(i).get());
        }
         
        System.out.println("执行完了");
 
        executorService.shutdown();
        long endtime = System.currentTimeMillis();
        System.out.println("-------执行时间------ " + (endtime-starttime)/1000  + " 秒");
    }
    ------------------------------------------------------------------   
    /**
     *  Future  invokeAll  方式一
     */
    public static void main3(String[] args) throws Exception{
        long starttime = System.currentTimeMillis();
        ExecutorService executor = Executors.newFixedThreadPool(1);
         
        List<RealData2> list = new ArrayList<RealData2>();
        for(int i=1; i<6 ;i++){
            list.add(new RealData2("a"+i));
        }
         
        System.out.println("请求完毕");
         
        List<Future<String>> invok = executor.invokeAll(list);
         
        for(Future<String> one :invok){
            // 取得call()方法的返回值 如果此时get方法没有执行完成,则依然会等待,知道所有都返回结果
            System.out.println("数据=" +  one.get());
        }
        System.out.println("执行完了");
        executor.shutdown();
         
        long endtime = System.currentTimeMillis();
        System.out.println("-------执行时间------ " + (endtime-starttime)/1000  + " 秒");
    }
    
    ------------------------------------------------------------------    
    /**
     * invokeAll  方式二
     */
    public static void main10(String[] args) throws Exception{
        ExecutorService executor = Executors.newFixedThreadPool(2);
        List<Callable<String>> calls = new ArrayList<Callable<String>>();
         
        System.out.println("程序启动");
         
        for(int i=0;i<10;i++){
            Callable<String> callable = new Callable<String>(){
                @Override
                public String call() throws Exception {
                    StringBuffer stringBuffer = new StringBuffer();
                    for (int y = 0; y < 10; y++) {
                        stringBuffer.append(new Random(2).nextInt()).append(y);
                        Thread.sleep(100);
                    }
 
                    return stringBuffer.toString();
                }
            };
            calls.add(callable);
        }
         
        List<Future<String>> invokeAll = executor.invokeAll(calls);
         
        for(Future<String> future : invokeAll){
            System.out.println("结果= " + future.get());
        }
         
        System.out.println("程序结束");
         
        executor.shutdown();
         
    }
    // 代码应用
    public void loadDictProductDef() throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(30);
        List<Callable<String>> calls = new ArrayList<Callable<String>>();

        List<DictProductDefEntity> defList = dictProductDefDao.loadDictProductDef();
        int total = defList.size();
        int pos = 0;
        while(pos < total){
            List<DictProductDefEntity> list = defList.subList(pos, Math.min(pos += 500, total));
            Callable<String> callable = new Callable<String>() {
                @Override
                public String call() throws Exception {
                    for (DictProductDefEntity one : list) {
                        DictProductDef def = TransformPacking.transDictProductDef(one);
                        productDefDao.save(def);
                    }
                    return String.valueOf(list.size());
                }
            };
            calls.add(callable);
        }
        logger.info("-----------------> 线城运行start");
        List<Future<String>> invokeAlls = executor.invokeAll(calls);
        for(Future<String> future : invokeAlls){
            logger.info("-------" + future.get());
        }
        logger.info("-----------------> 线城运行结束");
    }
     ------------------------------------------------------------------    
    /**
     * Future  submit 方式二
     */
    public static void main4(String[] args) throws Exception{
        long starttime = System.currentTimeMillis();
        ExecutorService executor = Executors.newFixedThreadPool(10);
         
        List<Future<String>> resultList = new ArrayList<Future<String>>();
        for(int i=1; i<6 ;i++){
            Future<String> future = executor.submit(new RealData2("a"+i));
            resultList.add(future);
        }
         
        System.out.println("请求完毕");
         
         
        for(Future<String> one :resultList){
            // 取得call()方法的返回值 如果此时get方法没有执行完成,则依然会等待,知道所有都返回结果
            System.out.println("数据=" +  one.get());
        }
        System.out.println("执行完了");
        executor.shutdown();
         
        long endtime = System.currentTimeMillis();
        System.out.println("-------执行时间------ " + (endtime-starttime)/1000  + " 秒");
    }
     
    /**
     *  超时
     */
    public static void main5(String[] args) throws Exception{
        long starttime = System.currentTimeMillis();
        ExecutorService executor = Executors.newFixedThreadPool(1);
         
        List<RealData2> list = new ArrayList<RealData2>();
        for(int i=1; i<20 ;i++){
            list.add(new RealData2("a"+i));
        }
         
        System.out.println("请求完毕");
         
        try{
//          List<Future<String>> invok = executor.invokeAll(list);
            // 5秒超时 程序停止
            List<Future<String>> invok = executor.invokeAll(list, 5, TimeUnit.SECONDS);
             
            for(Future<String> one :invok){
                // 取得call()方法的返回值 如果此时call()方法没有执行完成,则依然会等待,知道所有都返回结果
                System.out.println("数据=" +  one.get());
            }
            System.out.println("执行完了");
            executor.shutdown();
             
            long endtime = System.currentTimeMillis();
            System.out.println("-------执行时间------ " + (endtime-starttime)/1000  + " 秒");
        }catch(Exception e){
            System.out.println("时间超时,程序停止");
        }
    }
     
    public static void main7(String[]args){
        System.out.println("请求完毕");
        new Thread(new Runnable(){
            @Override
            public void run() {
                try {
                    System.out.println("等待执行中");
                    StringBuffer sb = new StringBuffer();
                    for(int i =1;i<6;i++){
                        TimeUnit.SECONDS.sleep(2);
                        System.out.println(sb.append("...").toString());
                    }
                    System.out.println("执行成功");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();;
        System.out.println("异步执行");
    }
   
    ------------------------------------------------------------------    
    public static void main8(String[] args) throws Exception{
        Integer total_task = 0;
        ExecutorService  pool = Executors.newFixedThreadPool(2);
        CompletionService<String> cService = new ExecutorCompletionService<String>(pool);
         
        System.out.println("请求完毕");
         
        for(int i=1; i<5 ;i++){
            total_task ++;
            cService.submit(new RealData2("a"+i));
        }
         
         
        for(int i=1; i<total_task ;i++){
            Future<String> future = cService.take();
            System.out.println("数据=" +  future.get());
        }
         
        pool.shutdown();
         
        System.out.println("执行完了");
         
        /**
         * ExecutorService 是按加入线程池的顺序返回，后面的任务完成了，前面的任务却没有完成，主程序就那样等待在那儿，直到完成再继续执行。
         * CompletionService 能够拿到最先完成的任务的返回值的返回值，它的submit的task不一定是按照加入时的顺序完成的
         */
    }
     
     -----------------------------------------------------------------------------------------------------------
    public static void main9(String[] args) throws Exception{
        Integer total_task = 0;
        ExecutorService  pool = Executors.newFixedThreadPool(2);
        BlockingQueue<Future<String>> queue = new LinkedBlockingQueue<Future<String>>();
         
        System.out.println("请求完毕");
         
        for(int i=1; i<5 ;i++){
            total_task ++;
            Future<String> future = pool.submit(new RealData2("a"+i));
            queue.add(future);
        }
         
         
        for(int i=1; i<total_task ;i++){
            Future<String> future = queue.take();
            System.out.println("数据=" +  future.get());
        }
         
        pool.shutdown();
         
        System.out.println("执行完了");
         
        /**
         * 主线程并不能保证首先获得的是最先完成任务的线程返回值,take方法是阻塞方法，后面的任务完成了，
         * 前面的任务却没有完成，主程序就等待在那儿，只到前面的完成了，它才知道原来后面的也完成了。
         */
    }

    -----------------------------------------------------------------------------------------------------------
    private static final ExecutorService EXECUTOR_SERVICE = Executors.newFixedThreadPool(100);

    public void asyncAnalysis(ContentDto dto) {
        EXECUTOR_SERVICE.submit(() -> {
            try {
                nlpAnalysis(dto);
            } catch (Exception e) {
                LOGGER.error("", e);
            } finally {
                redisService.sremOidKey(dto.getOid());
            }
        });
    }
    -----------------------------------------------------------------------------------------------------------
     
    public static void main11() throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
 
        FutureTask<List<String>> futureTask0 = new FutureTask<>(()->doCompanyAnalysis("逐笔列表","记住一起"));
        FutureTask<List<String>> futureTask1 = new FutureTask<>(()->doCompanyAnalysis("titaltotal","枚举值"));
        executorService.submit(futureTask0);
        executorService.submit(futureTask1);
 
        System.out.println("请求完毕");
 
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // 取得call()方法的返回值 如果此时get方法没有执行完成,则依然会等待
        System.out.println("数据0=" + futureTask0.get());
        System.out.println("数据1=" + futureTask1.get());
        System.out.println("执行完了");
 
        executorService.shutdown();
    }
     
    public static List<String> doCompanyAnalysis(String nf, String content) {
        List<String> list = new ArrayList<>();
        list.add(nf);
        list.add(content);
        return list;
    }
     
    public static void main(String[] args) throws Exception {
        main11();
    }
 
}
　


package chapter5;
 
import java.util.concurrent.Callable;
 
/*
 * Created by 13 on 2017/5/8.
 */
public class RealData2 implements Callable<String> {
    private String data;
 
    public RealData2(String data) {
        this.data = data;
    }
 
    @Override
    public String call() throws Exception {
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < 10; i++) {
            stringBuffer.append(data);
            Thread.sleep(100);
        }
 
        return stringBuffer.toString();
    }
}
-----------------------------------------------------------------------------------------------------------


package chapter5;
 
/**
 * 多线程同时操作同一个变量
 * @author fenglei.ma
 */
public class Counter {
 
    public static  int  count = 0;
 
    /**
     * 增加 synchronized 关键字,保证在多线程的时候，同一时刻只能有一个线城能够使用此方法
     */
    public synchronized static void inc() {
        try {
            Thread.sleep(1);
        } catch (Exception e) {
        }
        count++;
    }
 
    public static void main(String[] args) {
        System.out.println("程序启动");
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Counter.inc();
                }
            }).start();
        }
        try {
            Thread.sleep(1000); // 休眠1秒，确保线程执行完毕
        } catch (Exception e) {
        }
        // 如果不加 synchronized 这里每次运行的值都有可能不同,可能为1000 ,加上synchronized 才能保证累加
        System.out.println("运行结果:count=" + count);
    }
}
-----------------------------------------------------------------------------------------------------------
package com.csf.myproject.core.synchron;

/**
 * 多线程同时操作同一个变量
 * 使用同步 模拟多个窗口出售火车票
 * @author fenglei.ma 2018年3月20日 上午10:11:26
 */
public class Ticket implements Runnable {

    private int num;// 票数量
    private boolean flag = true;// 若为false则售票停止

    public Ticket(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        while (flag) {
            ticket();
        }
    }

    // 使用代码块  或者直接在方法上加synchornized
    private void ticket() {
        synchronized (this) {
            try {
                if (num <= 0) {
                    flag = false;
                    return;
                }
                Thread.sleep(20);// 模拟延时操作

                // 输出当前窗口号以及出票序列号
                System.out.println(Thread.currentThread().getName() + "售出票序列号：" + num--);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
/*  窗口01售出票序列号：5
    窗口01售出票序列号：4
    窗口03售出票序列号：3
    窗口03售出票序列号：2
    窗口03售出票序列号：1*/
    public static void main(String[] args) {
        Ticket ticket = new Ticket(5);
        Thread window01 = new Thread(ticket, "窗口01");
        Thread window02 = new Thread(ticket, "窗口02");
        Thread window03 = new Thread(ticket, "窗口03");
        window01.start();
        window02.start();
        window03.start();
    }
}
　
-----------------------------------------------------------------------------------------------------------
package chapter5;
 
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
/**
 * @author fenglei.ma
 */
public class ThreadManager {
 
    private static final ExecutorService threadPool = Executors.newCachedThreadPool();
 
    public static void main(String[] args) {
        ThreadManager th = new ThreadManager();
        th.start();
    }
 
    public void start() {
        threadPool.submit(new ResearchIndexerThread("http:", "get"));
        threadPool.submit(new ResearchIndexerThread("www.baidu.com:", "post"));
 
        Future<String> future = threadPool.submit(new GetExchangeThread("www.baidu.com:", "post"));
        System.out.println("结果=" + future);
        Future<String> future1 = threadPool.submit(new GetExchangeThread("www.baidu.com:", "post"));
        System.out.println("结果1=" + future1);
    }
 
    class ResearchIndexerThread implements Runnable {
        private String indexUrl;
        private String method;
 
        public ResearchIndexerThread(String indexUrl, String method) {
            this.indexUrl = indexUrl;
            this.method = method;
        }
 
        @Override
        public void run() {
            System.out.println(indexUrl + method);
        }
    }
 
    class GetExchangeThread implements Callable<String> {
        private String requestUrl;
        private String method;
 
        public GetExchangeThread(String requestUrl, String method) {
            this.requestUrl = requestUrl;
            this.method = method;
        }
 
        @Override
        public String call() {
            return requestUrl + method;
        }
    }
 
}