Java19线程相关优化

最新推荐文章于 2023-02-19 08:45:43 发布
最新推荐文章于 2023-02-19 08:45:43 发布
阅读量167 收藏
点赞数
分类专栏： 初顾茅庐 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44207220/article/details/127431655
版权

线程优化

原因：

1.一个线程占默认先占个1M的运行内存，而线程执行完是等待系统回收的，此时会浪费内存

2.每次使用就创建，运行完等待系统回收，需要频繁创建与回收

3.代码编写冗余

解决：

使用线程池：线程池拥有对线程的创建，回收或复用的容器

1.线程池是可以设置线程上限的

2.会复用线程

3.不会频繁的创建与回收线程

4.不用关心线程怎么创建，只需考虑每个线程执行的任务

线程池的体系结构

顶级接口：Executor

        提供的方法：

 void execute(Runnable command);

作用：执行线程任务，相当于启动线程

子类或子接口：

ExecutorService：

ExecutorService//这是个接口，继承于Executor 下面的都是它的一些方法

    void shutdown();//关闭线程池

    boolean isShutdown();//获取线程池是否关闭，可以看到其返回值为boolean

    Future<?> submit(Runnable task);//提交线程任务，相当于执行线程任务

     <T> Future<T> submit(Callable<T> task);//也是提交线程任务
boolean isTerminated();//判断线程是否执行结束（这是接口）

 

ScheduledExecutorService：调度线程池

ScheduledExecutorService//是个接口 继承于 ExecutorService
是所有调度线程池的父接口
提供的方法：

    schedule(Runnable command,//command线程任务
             long delay, //delay延迟时间
             TimeUnit unit);//unit时间单位
                作用：延迟执行

    schedule(Callable<V> callable,
             long delay, 
             TimeUnit unit);//同上

    scheduleAtFixedRate(Runnable command,//command线程任务
                        long initialDelay,//延迟时间
                        long period,//间隔时间  
                                     **间隔时间=本次任务开始时间-上次任务开始时间
                        TimeUnit unit);//unit时间单位
  作用：延迟重复任务执行，延迟多长时间后执行线程任务,间隔多久再次重复执行线程任务
        如果上次执行任务时间大于间隔时间，那么上次任务执行完毕后再执行本次任务

    scheduleWithFixedDelay(Runnable command,
                           long initialDelay,
                           long delay,//间隔时间
                                      **间隔时间=本次任务开始时间-上次任务结束时间
                           TimeUnit unit);

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
        这个东西最大的构造函数 7参

5参，6参，7参的了解一下

corePoolSize:核心线程数量,即线程中最少有几个线程
maximumPoolSize:线程池最大线程数量
keepAliveTime:销毁时间,空闲线程多久没有时间被销毁,不会销毁核心线程
unit:时间单位
workQueue:存放线程任务的队列
threadFactory:线程工厂
handler:复用机制与算法

线程池工具类

作用：提供了多种线程池创建的静态方法

类名：Executors

提供的方法：

1.  

 static ExecutorService newCachedThreadPool()

作用：创建一个可变线程池

特点：线程池中线程的数量不固定，根据线程任务的多少进行变化

例：

ExecutorService pool=Executors.newCachedThreadPool();

2.

static ExecutorService newFixedThreadPool(int nThreads)

作用：创建一个固定线程池

参数：线程个数

特点：线程池中线程的数量固定，根据参数（int nThreads）进行变化

例：创建有8个线程的线程池

ExecutorService pool=Executors.newFixedThreadPool(8);

 3.

static ExecutorService newSingleThreadExecutor()

作用：创建一个单线程的线程池

ExecutorService pool1 = Executors.newSingleThreadExecutor();

4.

static ExecutorService newWorkStealingPool()

作用：创建一个抢占线程池(JDK1.8出现)

特点：线程池中的线程都是守护线程，有一个窃取算法

5.

static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

作用：创建一个调度线程池

参数：线程池中的数量

特点：线程任务可以延迟执行

6.

static ScheduledExecutorService newSingleThreadScheduledExecutor()

作用：创建一个单例调度线程池，线程池中的线程只有一个

线程池的使用步骤

1.创建一个线程池

ExecutorService pool=Executors.newFixedThreadPool(3);

2.提交线程任务

使用：

execute(Runnable command)
submit(Runnable task)(建议使用)

还可以使用调度线程池特有的三个方法（
                                                    schedule

                                                    scheduleAtFixedRate

                                                     scheduleWithFixedDelay）

execute:

               1. 只能提交Runnable类型任务

                2.直接抛出执行任务时的异常，可以try cath 捕获

                3.没返回值

submit:

               1.可提交Runnable也可提交Callable类型的任务

                2.会吃掉异常，可用Future的get方法将异常抛出

                3.有返回值

试一试：

ExecutorService pool=Executors.newFixedThreadPool(3);
		
		pool.submit(new Runnable() {		
			@Override
			public void run() {
				System.out.println("使用一下");
			}
		});
		
		pool.execute(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("使用一下2");
			}
		});

 由于没有关闭，可以看到线程一直在运行

3.关闭线程池

线程池对象.shutdown();

	pool.shutdown();

 一般情况下：等线程池中线程执行完任务关闭后关闭，调度线程池特有的方法除外，调度线程池中执行延迟重复任务时，当线程池关闭时，此任务也会关闭

例：

 可以看到上面的例子直接关了

试试：

1个线程打印数字

1个线程打印小写字母

1个线程打印大写字母

package demo1;

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

public class Demo2 {
	
	public static void main(String[] args) {
		ExecutorService pool = Executors.newFixedThreadPool(3);
		
		pool.submit(new Runnable() {		
			@Override
			
			public void run() {
				Thread name=Thread.currentThread();	
				for (int i = 1; i <27; i++) {
					System.out.println(name.getName()+" "+i);
				}
			}
		});
		
		pool.submit(new Runnable() {
			
			@Override
			public void run() {
				Thread name=Thread.currentThread();
				for (int i = 97; i <123; i++) {
					System.out.println(name.getName()+" "+(char)i);
				}
			}
		});
		
		pool.submit(new Runnable() {		
			@Override
			public void run() {
				Thread name=Thread.currentThread();
				for (int i = 65; i <91; i++) {
				System.out.println(name.getName()+" "+(char)i);
				}
			}
		});
		
		pool.shutdown();
	}
}

 

线程任务优化

有时需要线程计算一些东西，这就要求线程要有返回值

JDK提供的Callable接口，该接口是有返回值的线程任务

1.创建Callable对象  这是个创建任务的。 而上一个创任务的是 Runnable

Callable 对象名 = new Callable<返回值类型>(){

                @Override

                public 返回值的数据类型 call() throws Exception {

                         return null;

        }

}

2.获取Callable对象的计算结果

                submit方法有返回值，返回值类型为Future型

                Callable的结果可以通过submit返回的Future对象调用get方法

                get方法会阻塞当前线程,直到对应的Callable得到结果

Future<返回数据类型> 对象名2= 线程对象.submit(Callable对象);

返回值数据类型 返回值 = 对象名2.get();

不能配合Thread使用，可以在线程池中使用

试一试：

          一个线程计算1-50的和,一个线程计算101~150的和,获取两个线程运算结果,并正在主线程打印输出

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test2 {
	public static void main(String[] args) throws InterruptedException, ExecutionException  {
		
		Callable<Integer>c1=new Callable<Integer>() {//创建一个Callable任务
			@Override
			public Integer call() throws Exception {//重写call方法
				int sum=0;
				for (int i = 0; i <51; i++) {
					sum=i+sum;	
				}
				return sum;
			}
		};
		
		ExecutorService pool = Executors.newFixedThreadPool(2);//创个有2个线程的线程池
		
		Future<Integer> f1 = pool.submit(c1);//用Future接收一下
		Future<Integer> f2 = pool.submit(new Callable<Integer>() {//试试用匿名内部类		
			@Override
			public Integer call() throws Exception {
				int sum=0;
				for (int i = 101; i < 151; i++) {					
					sum=i+sum;					
				}			
				return sum;
			}		
		});
		pool.shutdown();
		
		Integer num1 = f1.get();//记得在这抛出异常，抛出方法的异常
		Integer num2 = f2.get();// throws InterruptedException, ExecutionException 
	
		System.out.println(num1+num2);
	
	}
}

锁优化

主要便于使用

体系结构

Lock(接口)

        提供的方法：

                        void lock();关锁

                        void unlock();开锁

synchronized做同步


synchronized (锁对象) {
			
		//代码块
}

效果与Lock做同步相同 

Condition ReentrantLock();创建锁对象
锁对象.lock();

//同步代码块

锁对象.unlock();

      子类：

                ReentrantLock(互斥锁)

                ReadwriteLock（接口）

Condition:锁对象

               提供的方法

                        void await():休眠

                        void signal();唤醒一个        

                           void signal();唤醒所有

ReadwriteLock提供的方法

                Lock readLock():获取一个读锁

                Lock writeLock():获取一个写锁

        注意:

                读-读:异步

                读-写:同步

                写-写:同步

优点:提高了读写的效率

子类: ReentrantReadWriteLock(ReadWriteLock实现类)

例：

ReentrantLock Lock = new ReentrantLock();创建锁对象
while(Number>0) {			
			Lock.lock();			
			if(Number<=0) {
				Lock.unlock();
				return;
			}
			Number--;			
			System.out.println(Thread.currentThread().getName());
				Lock.unlock();			
}

四水木天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java性能优化实战视频全集
09-12
01 理论分析：性能优化，有哪些衡量指标?需要注意什么?.mp4 02 理论分析：性能优化有章可循，谈谈常用的切入点.mp4 03 深入剖析：哪些资源，容易成为瓶颈?.mp4 ...19 高级进阶：JVM常见优化参数.mp4
Java多线程优化方法及使用方式
baidu_37366055的博客
06-22 1941
多线程
第09讲：Java 线程优化 偏向锁，轻量级锁、重量级锁
ChinaDragon10的博客
07-21 510
Java 线程优化 偏向锁，轻量级锁、重量级锁
java 优化线程_JAVA线程优化
weixin_42107491的博客
02-16 352
Java并发编程：线程池的使用在前面的文章中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？在Java中可以通过线程池来达到...
Java多线程之线程池的监控和优化
MRZHQ的博客
02-19 2392
在Java多线程编程中，线程池是一种常见的技术，用于管理线程的创建和销毁。线程池中的线程可以被重复利用，从而减少了线程的创建和销毁的开销，提高了程序的性能。在Java中，线程池的监控和优化也是非常重要的，可以帮助我们更好地管理线程池，提高程序的性能和稳定性。
Java线程优化
家山的专栏
07-26 515
线程池 线程与协程 无锁设计 自旋锁、轻量级锁
Java第19讲：多线程（1）.txt
11-25
什么是线程 ... 举例：电脑管家同时进行清理垃圾、查杀修复、优化加速，这就是多线程。 如果是单线程的话，在运行清理垃圾时，其它两个都得在等待，不能运行。 多线程提高效率，同时运行。
java深度历险
03-07
JAVA线程的同步 19 中断线程 20 参考资料 20 JAVA垃圾回收机制与引用类型 22 JAVA垃圾回收机制 22 JAVA引用类型 23 参考资料 27 JAVA泛型 28 类型擦除 28 实例分析 29 通配符与上下界 30 类型系统 31 开发自己的泛型...
Java全能学习面试手册——Java面试题库.zip
10-01
41 JVM性能优化相关问题.pdf 42 JVM执行子系统.pdf 43 Kafka面试题.pdf 44 Linux面试题.pdf 45 Linux面试专题.pdf 46 MongoDB面试题.pdf 47 MongoDB面试专题.pdf 48 Mybatis面试题（含答案）_.pdf 49 MyBatis面试题....
Java常见面试题208道.docx
05-17
面试题包括以下十九部分：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql...
JAVA线程安全及性能的优化
04-10
不同的平台，内存模型是不一样的，但是jvm的内存模型规范是统一的。其实JAVA的多线程并发问题最终都会反映在java的内存模型上，所谓线程安全无非是要控制多个线程对某个资源的有序访问或修改。总结java的内存模型，要解决两个主要的问题：可见性和有序性。我们都知道计算机有高速缓存的存在，处理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型，屏蔽了底层平台内存管理细节，对于java开发人员，要清楚在jvm模型的基础上，如果解决多线程的可见性和有序性。
java 线程优化_多线程优化
weixin_39553272的博客
02-25 351
1.线程通信基础生成者消费者2.AsyncTaskFutureTask线程池问题和缺点3.HandlerThread优点例子IntentService原理和使用优点5.Loader优点例子1.线程通信基础1.1.普通的生产者消费者模式public class ThreadTest1 {//产品static class ProductObject{//线程操作变量可见public volatile ...
一文带你了解 Java 并发中的锁优化和线程池优化！
weixin_45560122的博客
12-31 364
今天，我们从 Java 内部锁优化，代码中的锁优化，以及线程池优化几个方面展开讨论。 Java 内部锁优化 当使用 Java 多线程访问共享资源的时候，会出现竞态的现象。即随着时间的变化，多线程“写”共享资源的最终结果会有所不同。 为了解决这个问题，让多线程“写”资源的时候有先后顺序，引入了锁的概念。每次一个线程只能持有一个锁进行写操作，其他的线程等待该线程释放锁以后才能进行后续操作。 从这个角度...
【java】java 一个线程占用多少内存
九师兄
07-05 7052
1.概述 偶然看到一个信息，说java的线程默认占用1M内存。然后我就查了查 线程堆栈也会申请内存。堆栈大小由 -Xss 选项指定，默认每个线程1M，幸运的是情况并非那么糟糕。操作系统会以延迟分配的方式分配内存页面，比如在第一次使用时分配，因此实际使用的内存要低得多，通常每个线程堆栈占用80至200KB。 还有其他 JVM 部件会占用本地内存，但它们在总内存消耗中通常比例不大。 2.验证 2.1 验证 什么都不做的验证 @Test public void threadSizeTest21() t.
java 多线程 优化,JAVA多线程优化居然有这么多思路
weixin_31762925的博客
03-14 235
今天，我们从 Java 内部锁优化，代码中的锁优化，以及线程池优化几个方面展开讨论。Java 内部锁优化当使用 Java 多线程访问共享资源的时候，会出现竞态的现象。即随着时间的变化，多线程“写”共享资源的终结果会有所不同。为了解决这个问题，让多线程“写”资源的时候有先后顺序，引入了锁的概念。每次一个线程只能持有一个锁进行写操作，其他的线程等待该线程释放锁以后才能进行后续操作。从这个角度来看，锁的...
Java性能优化的50个细节（珍藏版）
热门推荐
Java进阶之路
08-31 5万+
在JAVA程序中，性能问题的大部分原因并不在于JAVA语言，而是程序本身。养成良好的编码习惯非常重要，能够显著地提升程序性能。 1. 尽量在合适的场合使用单例 使用单例可以减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面： 第一，控制资源的使用，通过线程同步来控制资源的并发访问； 第二，控制实例的产生，以达到节约资源的目...
Java高效并发（八）----扩展线程池、退出线程池、优化线程池的线程数量
wangdongli_1993的博客
07-29 1697
 ThreadPoolExecutor是一个可以扩展的线程池 在 ThreadPoolExecutor类中有三个空的方法，可以看到这三个方法都是protected权限的 protected void beforeExecute(Thread t, Runnable r) { } protected void afterExecute(Runnable r, Throwable t) { } ...
java 优化线程_Java多线程性能优化
weixin_35050881的博客
02-16 440
大家使用多线程无非是为了提高性能，但如果多线程使用不当，不但性能提升不明显，而且会使得资源消耗更大。下面列举一下可能会造成多线程性能问题的点：死锁过多串行化过多锁竞争切换上下文内存同步下面分别解析以上性能隐患死锁关于死锁，我们在学习操作系统的时候就知道它产生的原因和危害，这里就不从原理上去累述了，可以从下面的代码和图示重温一下死锁产生的原因：publicclassLeftRightDeadlo...
多线程判断素数Java代码
最新发布
04-13
以下是判断素数的 Java 代码，可以使用多线程进行优化： ``` import java.util.concurrent.*; public class PrimeNumberChecker { public static boolean isPrime(int n) { if (n ) { return false; } for ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值