2019.7.21笔记——java并发线程相关

最新推荐文章于 2022-05-15 23:35:53 发布
最新推荐文章于 2022-05-15 23:35:53 发布
阅读量184 收藏
点赞数
分类专栏： java笔记——并发线程相关 java架构课程笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35262405/article/details/96759149
版权

目录

Executor

可以继承这个接口，通过实现execute这个方法，来开启线程完成任务。这个继承了executor的类就相当于任务管理器，可以调用这个类的execute方法来将任务交给这个类。

/**
 * 认识Executor
 * JDK8在线文档地址:https://docs.oracle.com/javase/8/docs/api/index.html
 */
public class Demo1_Executor implements Executor{

	public static void main(String[] args) {
		Demo1_Executor executor = new Demo1_Executor();
		executor.execute(()->{
			try {
				System.out.println("线程开始");
				TimeUnit.MILLISECONDS.sleep(500);
				System.out.println("线程结束");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
	}
	public void execute(Runnable command) {
		command.run();
	}
}

结果

任务开始
任务结束

关于偏向锁的具体介绍

Executorservice

用来管理Executor接口相关的线程池，可以接收其他线程池创建出来的对象。

FutureTask中的Callable和Future

FutureTask可以创建一个有返回值且可以抛异常的任务

Callable对Runnable进行了扩展,Runnable由于重写了,不能抛出异常，但是Callable可以有返回值,也可以抛出异常

Future则是任务的返回值

public class Demo6_Future {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		FutureTask<Integer> task = new FutureTask<>(()->{//new callable
			TimeUnit.MILLISECONDS.sleep(500);
			return 1000;
		});
		
		new Thread(task).start();
		
		System.out.println(task.get());
		
		ExecutorService service = Executors.newFixedThreadPool(5);
		Future<Integer> f = service.submit(()->{
			TimeUnit.MILLISECONDS.sleep(500);
			return 1;
		});
		System.out.println(f.get());
		System.out.println(f.isDone());
	}
}

需要注意的是在调用get方法取返回值的时候主线程的被阻塞的

结果

1000
1
true

executors

executor的工具类，可以创建许多线程池

newFixedThreadPool

可以设置线程池大小，队列式的线程池

Executorservice的shutdown方法会关闭线程池，但线程池的线程还是会执行完，并回收线程

shutdownNow方法会关闭线程并且直接停止线程

/**
 * 线程池的概念
 */
public class Demo5_ThreadPool {

	public static void main(String[] args) throws InterruptedException {
		ExecutorService service = Executors.newFixedThreadPool(5);
		for (int i = 0; i < 6; i++) {
			service.execute(()->{
				try {
					TimeUnit.MICROSECONDS.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName());
			});
		}
		
		System.out.println(service);
		
		service.shutdown();
		System.out.println(service.isTerminated());
		System.out.println(service.isShutdown());
		System.out.println(service);
		
		TimeUnit.SECONDS.sleep(5);
		System.out.println(service.isTerminated());
		System.out.println(service.isShutdown());
		System.out.println(service);
	}
}

结果

java.util.concurrent.ThreadPoolExecutor@58372a00[Running, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]
false
true
java.util.concurrent.ThreadPoolExecutor@58372a00[Shutting down, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]
pool-1-thread-1
pool-1-thread-2
pool-1-thread-4
pool-1-thread-3
pool-1-thread-5
pool-1-thread-1
true
true
java.util.concurrent.ThreadPoolExecutor@58372a00[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 6]

如果把shutdown方法换成shutdownNow，那么就会抛异常，因为直接中断了所有线程

java.util.concurrent.ThreadPoolExecutor@58372a00[Running, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]
false
true
java.util.concurrent.ThreadPoolExecutor@58372a00[Shutting down, pool size = 5, active threads = 5, queued tasks = 0, completed tasks = 0]
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at com.luban.demo1.Demo5_ThreadPool.lambda$main$0(Demo5_ThreadPool.java:18)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
pool-1-thread-3
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at com.luban.demo1.Demo5_ThreadPool.lambda$main$0(Demo5_ThreadPool.java:18)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
pool-1-thread-2
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at com.luban.demo1.Demo5_ThreadPool.lambda$main$0(Demo5_ThreadPool.java:18)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
java.lang.InterruptedException: sleep interrupted
pool-1-thread-1
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at com.luban.demo1.Demo5_ThreadPool.lambda$main$0(Demo5_ThreadPool.java:18)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
pool-1-thread-5
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at com.luban.demo1.Demo5_ThreadPool.lambda$main$0(Demo5_ThreadPool.java:18)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
pool-1-thread-4
true
true
java.util.concurrent.ThreadPoolExecutor@58372a00[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 5]

需要注意的是这种线程池只有关闭了才会回收线程

newCachedThreadPool

缓存式的线程池，来一个任务创建一个线程，空闲的线程就接上，每个线程到了一定时间会回收，每个线程都有各自的存活时间

public class Demo8_CachedPool {

	public static void main(String[] args) throws InterruptedException {
		ExecutorService service = Executors.newCachedThreadPool();
		System.out.println(service);
		
		for (int i = 0; i < 2; i++) {
			service.execute(()->{
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName());
			});
		}
		
		System.out.println(service);
		
		TimeUnit.SECONDS.sleep(60);
		System.out.println(service);

		TimeUnit.SECONDS.sleep(1);
		System.out.println(service);
	}
}

这种线程池的线程上限为integer的最大值，而且默认为最大值
结果

java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
pool-1-thread-2
pool-1-thread-1
java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 2, active threads = 0, queued tasks = 0, completed tasks = 2]
java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 2]

可以看到因为来了两个任务所以启动了两个线程

newSingleThreadExecutor

每次只有一个任务会执行，一个一个执行

public class Demo9_SingleThreadPool {

	public static void main(String[] args) {
		ExecutorService service = Executors.newSingleThreadExecutor();
		
		for (int i = 0; i < 5; i++) {
			final int j = i;
			service.execute(()->{
				System.out.println(j + " " + Thread.currentThread().getName());
			});
		}
	}
}

结果

0 pool-1-thread-1
1 pool-1-thread-1
2 pool-1-thread-1
3 pool-1-thread-1
4 pool-1-thread-1

可以看到任务是一个一个完成的

newScheduledThreadPool

可以设置任务开始执行时间，循环执行的间隔时间

public class Demo10_ScheduledPool {

	public static void main(String[] args) {
		ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
		
		service.scheduleAtFixedRate(()->{
			try {
				TimeUnit.MILLISECONDS.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName());
		}, 0, 500, TimeUnit.MILLISECONDS);
	}
}

结果

pool-1-thread-1
pool-1-thread-1
pool-1-thread-2
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
............循环执行，不会停止

这个方法的第一个参数是Runnable接口，第二个参数是开始的时间，第二个是循环执行的间隔时间，第四个参数是时间单位

scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

newWorkStealingPool

这线程池里面的线程是守护线程，同时这里面的线程如果在执行完自己的任务后会直接从别的线程的任务队列里偷取任务

public class Demo11_WorkStealingPool {
	public static void main(String[] args) throws InterruptedException {
		ExecutorService service = Executors.newWorkStealingPool();
		System.out.println(Runtime.getRuntime().availableProcessors());
		
		service.execute(new R(1000));
		service.execute(new R(2000));
		service.execute(new R(2000));
		service.execute(new R(2000));
		service.execute(new R(2000));
		service.execute(new R(2000));
		service.execute(new R(2000));
		service.execute(new R(2000));
		service.execute(new R(2000));

		TimeUnit.SECONDS.sleep(10);
	}
	
	static class R implements Runnable{
		int time;
		public R (int t){
			this.time = t;
		}
		@Override
		public void run() {
			try {
				TimeUnit.MILLISECONDS.sleep(time);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(time + " " + Thread.currentThread().getName());
		}
	}
}

结果

8
1000 ForkJoinPool-1-worker-1
2000 ForkJoinPool-1-worker-6
2000 ForkJoinPool-1-worker-0
2000 ForkJoinPool-1-worker-2
2000 ForkJoinPool-1-worker-5
2000 ForkJoinPool-1-worker-3
2000 ForkJoinPool-1-worker-4
2000 ForkJoinPool-1-worker-7
2000 ForkJoinPool-1-worker-1

因为里面的线程都是守护线程所以当主线程的睡眠时间更短时会有不一样的现象，现在把时间设为1秒

8
1000 ForkJoinPool-1-worker-1

可以看到只有第一个线程执行完了任务，因为主线程结束了，守护线程也会跟着结束

ForkJoinPool

通过fork和join方法实现任务的切分

public class Demo12_ForkJoinPool {
	static int[] nums = new int[1000000];
	static final int MAX_NUM = 50000;
	static Random r = new Random();

	static {
		for(int i=0; i<nums.length; i++) {
			nums[i] = r.nextInt(100);
		}
		System.out.println(Arrays.stream(nums).sum());
	}
	
	/*static class AddTask extends RecursiveAction {
		
		int start, end;
		
		AddTask(int s, int e) {
			start = s;
			end = e;
		}

		@Override
		protected void compute() {
			if(end-start <= MAX_NUM) {
				long sum = 0L;
				for(int i=start; i<end; i++){
					sum += nums[i];
				}
				System.out.println(sum);
			} else {
				int middle = start + (end-start)/2;
				AddTask subTask1 = new AddTask(start, middle);
				AddTask subTask2 = new AddTask(middle, end);
				subTask1.fork();
				subTask2.fork();
			}
		}
	}*/

	static class AddTask extends RecursiveTask<Long> {

		int start, end;
		
		AddTask(int s, int e) {
			start = s;
			end = e;
		}

		@Override
		protected Long compute() {
			if(end-start <= MAX_NUM) {
				long sum = 0L;
				for(int i=start; i<end; i++){
					sum += nums[i];
				}
				return sum;
			} 
			int middle = start + (end-start)/2;
			AddTask subTask1 = new AddTask(start, middle);
			AddTask subTask2 = new AddTask(middle, end);
			subTask1.fork();
			subTask2.fork();
			return subTask1.join() + subTask2.join();
		}
	}
	
	public static void main(String[] args) {
		ForkJoinPool forkJoinPool = new ForkJoinPool();
		AddTask task = new AddTask(0, nums.length);
		forkJoinPool.execute(task);
		long result = task.join();
		System.out.println(result);

		try {
			TimeUnit.SECONDS.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

结果

49513285
49513285

想要使用这个线程池必须要有继承RecursiveTask类的对象，同时要把执行的任务重写在compute方法中，在方法中，通过fork来分配子任务，join方法得到子任务的返回值

ThreadPoolExecutor

通过调用ThreadPoolExecutor可以自定义线程池

下面是它的构造器

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) 
创建具有给定的初始参数和默认线厂和拒绝执行处理程序的一个新的 ThreadPoolExecutor。  

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) 
创建具有给定的初始参数和默认线厂一个新的 ThreadPoolExecutor。 
 
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) 
创建一个新的 ThreadPoolExecutor与给定的初始参数和默认拒绝执行处理程序。  

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) 
创建具有给定的初始参数的一种新 ThreadPoolExecutor。

我们可以通过返回一个ThreadPoolExecutor，其中的参数可以自定义，这样同样也可以创建一个线程池

这里只对第一个做解释

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)

corePoolSize是核心线程多少
maximumPoolSize是最大线程数
keepAliveTime是除核心线程之外的线程最大空闲时间
unit是时间单位
workQueue是每个线程的任务队列类型

execute()的逻辑应该是：

  1. 如果当前运行的线程，少于corePoolSize，则创建一个新的线程来执行任务。
  2. 如果运行的线程等于或多于 corePoolSize，将任务加入 BlockingQueue。
  3. 如果加入 BlockingQueue 成功，需要二次检查线程池的状态如果线程池没有处于Running，则从 BlockingQueue 移除任务，启动拒绝策略。
  4. 如果线程池处于 Running状态，则检查工作线程（worker）是否为0。如果为0，则创建新的线程来处理任务。如果启动线程数大于maximumPoolSize，任务将被拒绝策略拒绝。
  5. 如果加入 BlockingQueue 。失败,则创建新的线程来处理任务。
  6. 如果启动线程数大于maximumPoolSize，任务将被拒绝策略拒绝。

线程池 execute() 的工作逻辑

线程池简要模型

在这里插入图片描述

线程池的线程的多少最优一般是cpu的核心数加一

ww0peo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程基础篇（一）之线程
weixin_48013460的博客
12-29 2394
前言 并发编程的目的是为了让程序运行得更快，但是，并不是启动更多的线程就能让程序最 大限度地并发执行。在进行并发编程时，如果希望通过多线程执行任务让程序运行得更快，会 面临非常多的挑战，比如上下文切换的问题、死锁的问题，以及受限于硬件和软件的资源限制问题。这一块内容也是面试核心考点之一，所以博主将以线程为起点，从0到1一起与小伙伴们走去Java并发编程之路上走一遭！ 正文 进程？线程？傻傻分不清？ 何谓进程 进程通常是程序、应用的同义词。进程的本质是一个正在执行的程序，程序运行时系统会创建一个进程，并且给每
Java进阶总结——并发（二）：线程基础
大唐一品
09-28 109
线程
Java多线程——FutureTask+ExecutorService
kw-home
10-30 1074
1.Java并发编程：Callable、Future和FutureTask 创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。 这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。 如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。 而自从Java 1.5开始，就提供了Callable和Futur...
java线程池
java_zjs的博客
05-02 558
线程池的一些解释文字 一：使用线程池的好处： 1、使用线程池可以重复利用已有的线程继续执行任务，避免线程在创建和销毁时造成的消耗 2、由于没有线程创建和销毁时的消耗，可以提高系统响应速度 3、通过线程可以对线程进行合理的管理，根据系统的承受能力调整可运行线程数量的大小等 二、如何使用线程池（Executors是所有线程池的顶级父类） 1.创建线程池对象（使用 Executors关键字来调用相应的线程方法） 2.提交任务 3.关闭线程池（使用 shutdown） 三：线程池的一些关键...
ExecutorService生命周期
爱拼才会赢，技术成就梦想！
01-04 785
ExecutorService接口继承了Executor接口，定义了一些生命周期的方法 public interface ExecutorService extends Executor { void shutdown(); List shutdownNow(); boolean isShutdown(); boolean isTerminated(); boolean awaitTe
Java多线程初识
weixin_43188446的博客
05-15 968
初识多线程 线程是操作系统中CPU运行调度的最小单位，一个进程包含多个线程，每个线程可以执行不同的任务。并发执行可以让程序运行得更快 多线程下的并行、并发 并行 指同一个的时间中，同时执行的线程(两个或以上)。 例如：一台机器需要花10分钟才可以执行完成的任务，两台机器可以拆分任务那么就只需要各5分钟在同一时刻就可以完成，这就代表并行。 注：一个机器可以理解为一个单核的CPU，那么并行就需要多核CPU 并发 多个线程同时请求执行任务，但是在这段时间内就只可以执行一个线程，然而CPU拥有很快的速度，
Java线程死锁以及问题定位
weixin_38296425的博客
08-08 3069
死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象,若无外力干涉那它们都将无法推进下去，如果系统资源充足，进程的资源请求都能够碍到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。 产生死锁主要原因: 系统资源不足 进程运行推进的顺序不合适 资源分配不当 发生死锁的四个条件： 互斥条件，线程使用的资源至少有一个不能共享的。 至少有一个线程必须持有一个资源且正在等待获取一个当前被别的线程持有的资源。 资源不能被抢占。 循环等待。 如何解决死锁问.
超详细的Java复习知识点2019——个人笔记.zip
06-24
7. **多线程**：Java内置了对多线程的支持，笔记可能会讲解Thread类的使用，线程同步机制（如synchronized，wait()，notify()等）以及并发工具类（如ExecutorService，Semaphore等）。 8. **接口与抽象类**：Java中...
《NVM-Express-1_4-2019.06.10-Ratified》学习笔记（1）
axqix8835的博客
08-11 1590
材料说明： 文档《NVM-Express-1_4-2019.06.10-Ratified.pdf》来自于NVMe网站：https://nvmexpress.org/ 笔记目的是学习NVMe基本概念，为学习NVMe over Fabric打基础，所以当前记录中与PCIe相关的内容，以及其他无关紧要的内容，都先跳过。 1 引言（入门简介） 1.2 内容范围 NVMe基础规格说明书为...
java7rt.jar源码-JVM:JVM学习笔记
06-04
java7 rt.jar源码虚拟机 [目录] 联谊会 java.util.concurrent java.util.concurrent java.util.locks java.util.atomic 进程/线程 并发/并行 线程 package com.ntuzy.juc_01 ; import java.util.concurrent.Callable...
JAVA开发手册华山版.pdf_java_
10-02
4. **并发编程**：针对Java多线程编程，手册提供了关于线程安全、同步机制、并发集合等方面的指导，包括 volatile、synchronized 关键字的使用，以及并发工具类如 `ExecutorService` 和 `Future` 的应用。...
java.util.concurrent包之 LinkedBlockingQueue 阻塞队列 学习笔记
JC.Lin的博客
02-23 828
LinkedBlockingQueue 类图 LinkedBlockingQueue 中也有两个 Node 分别用来存放首尾节点，并且里面有个初始值为 0 的原子变量 count 用来记录队列元素个数，另外里面有两个 ReentrantLock 的独占锁，分别用来控制元素入队和出队加锁，其中 takeLock 用来控制同时只有一个线程可以从队列获取元素，其他线程必须等待，putLock 控制同时...
处理线程未捕获的异常UncaughtExceptionHandler
yeguangchen的博客
08-16 1144
为什么需要UncaughtExceptionHandler？ 1.主线程可以轻松发现异常，子线程却不行（比如子线程抛出了RuntimeException异常，而主线程start子线程后后续还有很多逻辑，子线程的异常可能夹杂在日志里无法轻松发现）。 2.子线程异常无法用传统方法捕获（比如在主方法里try/catch不能捕获到子线程里面的异常，他只能捕获主线程的异常）。 处理多线程子线程的异常有两种方式： 第一种是手动在每个run方法里进行try/catch,不推荐这种方式，写起来繁琐。 第二种是利用Uncau
java thread 异常_Java Thread异常的处理方式
weixin_32827773的博客
02-16 1777
run()方法不允许throw exception，因此所有的异常必须在run()方法内进行处理。方式一：使用try-catchpackage study.thread.exceptiontest;/**** 使用try-catch处理线程异常**/public class ExceptionHandle1 implements Runnable {@Overridepublic void run...
Thread.748的javaFX多线程并发问题
weixin_40804987的博客
06-26 2585
最近在尝试用javafx写一个简单的2D游戏，没有仔细学过FX和多线程，就闭门造车一次。在制作过程中，发现当移动射击等操作越来越多、主页面图形变化逐渐丰富的时候，开始出现卡顿，最后有概率地出现Not on java FX Application问题，接着出现NullPointerException导致程序崩溃。逐步排查后发现可能是并发问题，之前一直没有考虑到并发，而是简单地使用Platform.r...
Java线程池了解一下
dearKundy的博客
01-28 2153
为什么需要使用线程池 1、减少线程创建与切换的开销 在没有使用线程池的时候，来了一个任务，就创建一个线程，我们知道系统创建和销毁工作线程的开销很大，而且频繁的创建线程也就意味着需要进行频繁的线程切换，这都是一笔很大的开销。 2、控制线程的数量 使用线程池我们可以有效地控制线程的数量，当系统中包含大量并发线程时，会导致系统性能剧烈下降。 线程池做了什么 重复利用有限的线程 线程池中会预先创...
Java虚拟机（一）JVM参数、常用命令
yangwei2048的博客
12-03 8205
1、JVM参数类型 （1）标准参数         例如：-help                    -server -client                    -version -showversion                    -cp -classpath （2）X参数：非标准化参数          -Xint：解释执行          -Xcomp：第一次使用...
Java多线程与高并发深度解析——面试必备
在Java编程语言中，多线程和高并发是核心特性，尤其在面试中，这部分内容是考察开发者技术深度的重要部分。本篇文章将深入探讨Java中的`volatile`关键字、Java内存模型（JMM）以及它们在多线程和高并发场景下的应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值