Java并发编程

 

目录

 

1、JUC并发编程

2、线程池

3、Executor接口

 4、ExecutorServicw接口

(1)语句：创建线程池

(2)语句：调用线程：

执行结果：​编辑 5、对比调用线程池和直接创建线程程序执行速度

 6、插入知识点：输出系统时间/程序执行的时间

---

1、JUC并发编程

它是Java.util.concurrent包的简写

2、线程池

其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建和销毁线程对象的错误，节省了资源的开销

3、Executor接口

这是Java并发编程的基础接口，此接口只有一个方法execute(),表示接收一个实现了Runnale接口的对象做为执行参数来执行，该对象我们可以理解为需要执行的任务，至于这个任务交给哪个线程执行，由具体的Executor决定

 4、ExecutorServicw接口

它表示线程池，它是Executor接口的子接口
它有一个shutdown（）;该线程池不再接受新的任务，等待队列中 任务会继续执行完成

executor.shutdown();

Executors帮助类，这是Executor接口的帮助类，它提供了一系列静态的工厂方法帮我们创建不同的ExecutorService线程池对象

executor.shutdown();

 newFixedThreadPool(线程数)——创建指定大小 的线程

(1)语句：创建线程池

 ExecutorService executor=
                Executors.newFixedThreadPool(10);

(2)语句：调用线程：

 executor.execute(new MyThread());

newSingleThreadExecutors()

创建一个只有一个线程的线程池

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test15 {
    public static void main(String[] args) {
        ExecutorService executor=
                Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executor.execute(new MyThread());
        }
        executor.shutdown();
    }
}

public class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()
                + "线程正在执行……");
    }
}

执行结果： 5、对比调用线程池和直接创建线程程序执行速度

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test17 {
    public static void main(String[] args) {
      myPool();
    }
    //50万线程不用线程池
   
    //50万线程用线程池
    private static void myPool(){
        long start= System.currentTimeMillis();
        Random random=new Random();
        List<Integer> list =new ArrayList<>();
        ExecutorService executorService =
                Executors.newFixedThreadPool(10);
        for (int i = 0; i < 500000; i++) {
           executorService.execute(()->{
               list.add(random.nextInt());
           });
        }
        System.out.println("50万线程线程池,需要时间" + (System.currentTimeMillis() -start));
    }

}

 

执行结果：

 

 

原因：创建内含10个线程线程池，然后调用50w次

不用线程池：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test17 {
    public static void main(String[] args) {
      myThread();
    }
    //50万线程不用线程池
    private static void myThread(){
        long start= System.currentTimeMillis();
        Random random=new Random();
        List<Integer> list =new ArrayList<>();
        for (int i = 0; i < 500000; i++) {
            Thread thread =new Thread(()->{
                list.add(random.nextInt());
            });
            thread.start();
        }
        System.out.println("50万线程不用线程池,需要时间" + System.currentTimeMillis());
    }
   
}

执行结果： 

原因：创建50个线程，所以时间长

Thread thread =new Thread(()->{
                list.add(random.nextInt());
            });

 6、插入知识点：输出系统时间/程序执行的时间

​
public class Test16 {
    public static void main(String[] args) {
  long start =System.currentTimeMillis();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(System.currentTimeMillis() - start);
    }
}

​

输出系统时间：

 System.out.println(System.currentTimeMillis());

程序执行的时间

 long start =System.currentTimeMillis();
 System.out.println(System.currentTimeMillis() - start);