JavaEE学习日志持续更新----> 必看!JavaEE学习路线(文章总汇)
线程池:容器(集合),存储线程
当程序开始启动的时候,创建一些线程,存储到集合(LinkedList:增删快)中。
当使用线程完成线程任务的时候,我们可以从线程池中取出线程使用。
Thread t = linked.removeFirst();
使用完线程,需要把线程再归还给线程池
linked.addLast(t);
好处:避免了线程的重复创建和销毁,提高了程序效率
在JDK1.5之后,java内置了线程池技术,可以直接使用
java.util.concurrent.Executors类:生产线程池的工厂类
静态方法:
static ExecutorService newFixedThreadPool(int nThreads)
创建一个线程池,该池重用在共享的无界队列中运行的固定数量的线程。
java.util.concurrent.ExecutorService
Future submit(Runnable task)
提交Runnable任务以执行并返回表示该任务的Future。
void shutdown()
关闭,销毁线程池,
注意:若销毁线程池之后,再使用线程池,会出现RejectedExecutionException异常
示例1:使用线程池执行Runnable线程任务
public class Demo01 {
public static void main(String[] args) {
//1.使用线程池工厂类Executors中的静态方法newFixedThreadPool,生产一个指定线程数量的线程池
ExecutorService es = Executors.newFixedThreadPool(2);
//2.使用线程池ExecutorService中的方法submit,提交线程任务
es.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程执行了线程任务");//pool-1-thread-2线程执行了线程任务
}
});
es.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程执行了线程任务");//pool-1-thread-1线程执行了线程任务
}
});
es.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程执行了线程任务");//pool-1-thread-2线程执行了线程任务
}
});
//void shutdown() 关闭,销毁线程池,销毁之后线程池消失,不能再使用
es.shutdown();
//再使用线程池,会报异常,RejectedExecutionException
/*es.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程执行了线程任务");//pool-1-thread-2线程执行了线程任务
}
});*/
}
}
示例2:使用线程池执行Callable接口提交的线程任务
java.util.concurrent.ExecutorService
Future
提交值返回任务以执行并返回表示任务的挂起结果的Future。
java.util.concurrent.Callable<泛型>接口:用来设置线程任务
抽象方法:
V call()
:返回一个和接口类型相同的值
可以使用Future接口中的方法V get()
获取Callable接口的返回值
public class Demo02 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//1.使用线程池工厂类Executors中的静态方法newFixedThreadPool,生产一个指定线程数量的线程池
ExecutorService es = Executors.newFixedThreadPool(2);
//2.使用线程池ExecutorService中的方法submit,提交线程任务
Future<Integer> f1 = es.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return new Random().nextInt(100);//[0,100)
}
});
System.out.println(f1);//java.util.concurrent.FutureTask@6e8cf4c6
//使用Future接口中的方法get获取Callable接口的返回值
// V get() 如果需要等待计算完成,然后检索其结果。
System.out.println(f1.get());//[0,100)
}
}
使用Callable返回一个线程任务:获取1到指定整数之间的和
返回:如1-100
代码实现:
public class Demo03Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//1.使用线程池工厂类Executors中的静态方法newFixedThreadPool,生产一个指定线程数量的线程池
ExecutorService ex = Executors.newFixedThreadPool(2);
//使用键盘输入获取整数
System.out.println("请输入一个整数");
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
//2.使用线程池ExecutorService中的方法submit,提交线程任务
Future<Integer> f = ex.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
//获取1到指定整数之间的和
int sum = 0;
for (int i = 1; i <= a; i++) {
sum += i;
}
return sum;
}
});
System.out.println(f.get());
}
}
()->{}
一些参数,一个箭头,一段代码
详细说明:
():接口中抽象方法的参数 (int a,int b) (String s)
->:传递,把参数传递给方法体使用
{}:重写接口抽象方法的方法体
示例1:匿名内部类与Lambda表达式的区别
public class Demo01 {
public static void main(String[] args) {
//使用匿名内部类,简化程序
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类");
}
}).start();
//使用Lambda表达式,简化匿名内部类
//new Runnable() {
// @Override
// public void run
//上述代码被简化了
new Thread(()->{
System.out.println("Lambda表达式");
}).start();
}
}
示例2:简化有参数有返回值的方法
需求:
java.util.Arrays:
static
根据指定比较器引发的顺序对指定的对象数组进行排序。
public class Demo02 {
public static void main(String[] args) {
//1. 定义一个数组。类型使用Person,存储Person对象
Person[] arr = {
new Person("aaa", 18),
new Person("bbb", 20),
new Person("ccc", 15),
};
// 2. 使用数组工具类Arrays中的方法sort,对象Person按照年龄降序排序
//匿名内部类
Arrays.sort(arr, new Comparator<Person>() {
@Override
public int compare(Person o1 , Person o2) {
//降序
return o2.getAge()-o1.getAge();
}
});
//使用Lambda表达式,简化匿名内部类
Arrays.sort(arr,(Person o1 , Person o2)->{
return o2.getAge()-o1.getAge();
});
//遍历数组
for (Person p : arr) {
System.out.println(p);
}
}
}
~
示例1:
Lambda表达式
new Thread(()->{
System.out.println("Lambda表达式");
}).start();
简化Lambda表达式
//简化Lambda表达式
new Thread(()-> System.out.println("Lambda表达式")).start();
示例2:
Lambda表达式
Arrays.sort(arr, (Person o1, Person o2) -> {
return o2.getAge() - o1.getAge();
});
简化Lambda表达式
Arrays.sort(arr, (o1, o2) -> o2.getAge() - o1.getAge());
自定义一个ABC接口,定义一个静态方法method
public interface ABC {
public abstract void method(int a);
}
使用匿名内部类,Lambda表达式,简化Lambda表达式调用method方法
public class Demo04 {
/*
定义一个方法,参数使用ABC接口
*/
public static void show(ABC abc,int a){
abc.method(a);
}
public static void main(String[] args) {
//匿名内部类
show(new ABC() {
@Override
public void method(int a) {
System.out.println(a);
}
},10);
//Lambda表达式
show((int a)->{
System.out.println(a);
},10);
//简化Lambda表达式
show((int a)-> System.out.println(a),10);
}
}~