scala学习 --------java实现并发编程（理解）

版权声明：个人原创，转载请标注！ https://blog.csdn.net/Z_Date/article/details/84349435

2.1 java中实现线程方式（2种）

使用继承Thread类或者实现Runable接口来编写线程，效率很低。

没有办法实现对线程有效的管理，造成资源浪费。

2.2 java并发编程Executors接口

2.2.1. Java通过Executors接口提供四种线程池

newFixedThreadPool （execute）创建一个定长的线程池。



//固定长度线程池
public static void test1(int a){
    //第一步：创建线程池,参数：创建几个线程
    ExecutorService executorService = Executors.newFixedThreadPool(a);
    //第二：使用循环创建多个线程
    for(int i=0;i<10;i++){
        //创建线程
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("--->"+Thread.currentThread().getName());
            }
        });
    }
}
​
​
public static void main(String[] args) {
    test1(3);
}

newCachedThreadPool（execute） 创建一个缓存线程池。好处是可以回收使用过的线程。



//固定长度线程池
public static void test2() {
    //第一步：创建线程池,参数：创建几个线程
    ExecutorService executorService = Executors.newCachedThreadPool();
    //第二：使用循环创建多个线程
    for(int i=0;i<50;i++){
        //创建线程
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("--->"+Thread.currentThread().getName());
            }
        });
    }
}

newScheduledThreadPool 创建一个周期任务线程池

定时任务：schedule(线程，延迟时间，时间单位TimeUtil.SECONDS)

        //第一步：创建线程池,参数：创建几个线程
        ScheduledExecutorService sc = Executors.newScheduledThreadPool(2);
        //第二步：获取定时任务线程
//        sc.schedule(new Runnable() {
//            @Override
//            public void run() {
//                for (int i=0;i<10;i++){
//                    System.out.println("----------->"+i);
//                }
//            }
//        },10,TimeUnit.SECONDS);

周期任务：scheduleAtFixedRate(线程，延迟时间，周期时间，时间单位TimeUtil.SECONDS)

//第二步：获取周期任务线程
sc.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println("----------->我在回收垃圾对象！");
    }
},5,1,TimeUnit.SECONDS);
newSingleThreadExecutor （execute）创建一个单线程的线程池

//固定长度线程池
public static void test4(){
    //第一步：创建线程池,参数：创建几个线程
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    //第二：使用循环创建多个线程
    for(int i=0;i<10;i++){
        //创建线程
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("--->"+Thread.currentThread().getName());
            }
        });
    }
}

使用Executor线性池进行并发编写的好处是，有效的管理线程，提高线程执行效率。提高cpu使用率

2.2.3. Future (调用submit方法返回Future)

Future 可以封装异步计算的结果,只需调用一个阻塞的 get() 方法就可以取出结果了，

public static Future test5(){
    //第一步：创建线程池,参数：创建几个线程
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    //第二：使用循环创建多个线程
    //创建线程
    Future future= executorService.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "hello world";
        }
    });
    return future;
}
Future future=test5();
String st=(String)future.get();
System.out.println(st);