Java程序设计（高级及专题）- 多线程

于 2022-04-17 13:27:48 发布
阅读量100 收藏 1
点赞数
分类专栏： Java 文章标签： 经验分享 面试 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69379016/article/details/124228461
版权

public static void main(String[] args) {

Son r1=new Son();

Thread t1=new Thread(r1,“大明”);

Thread t2=new Thread(r1, “小明”);

t1.start();

t2.start();

try {

t1.join();//等待线程结束

t2.join();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

r1.show();

}

}

总结：晓宇感觉在实体运用中，对象锁和方法锁没多大区别，大家可以哪个用着顺手用哪个，不过还是要具体问题具体分析，同样要根据公司项目来决定，当然在刚入职的小白来说，没有三年五载的你压根不用去考虑线程的问题，因为java基本上都是开发企业的项目，正常来说不是什么金融银行的工程，用不上线程锁这种东西，但我们作为一个开发人员还是要知道的，下面是晓宇对锁的理解。

  • A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的， 则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。

  • B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。

  • C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

[资源下载](()

[](()死锁

================================================================

进程A中包含资源A,进程B中包含资源B，A的下一步需要资源B，B的下一步需要资源A，所以它们就互相等待对方占有的资源释放，所以也就产生了一个循环等待死锁。

public class DeadLock {

public static void main(String[] args) {

Thread t1 = new Thread(new DeadLockTest(true));

Thread t2 = new Thread(new DeadLockTest(false));

t1.start();

t2.start();

}

}

class DeadLockTest implements Runnable{

private boolean flag;

static Object obj1 = new Object();

static Object obj2 = new Object();

public DeadLockTest(boolean flag) {

this.flag = flag;

}

public void run(){

if(flag){

synchronized(obj1){

System.out.println(“if lock1”);

synchronized (obj2) {

System.out.println(“if lock2”);

}

}

}else{

synchronized (obj2) {

System.out.println(“else lock2”);

synchronized (obj1) {
《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》开源
System.out.println(“else lock1”);

}

}

}

}

}

死锁形成的必要条件总结（都满足之后就会产生）：

①、互斥条件：资源不能被共享，只能被同一个进程使用；

②、请求与保持条件：已经得到资源的进程可以申请新的资源；

③、非剥夺条件：已经分配的资源不能从相应的进程中强制剥夺；

④、循环等待条件：系统中若干进程形成环路，该环路中每个进程都在等待相邻进程占用的资源。

[](()线程池

=================================================================

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

线程池的作用：

线程池作用就是限制系统中执行线程的数量。

根 据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排 队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池 中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池:

1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

  • 比较重要的几个类：

ExecutorService： 真正的线程池接口。

ScheduledExecutorService： 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。

ThreadPoolExecutor： ExecutorService的默认实现。

ScheduledThreadPoolExecutor： 继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

  • newCachedThreadPool：

public static void main(String[] args) {

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

for (int i = 0; i < 10; i++) {

final int index = i;

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

cachedThreadPool.execute(new Runnable() {

public void run() {

System.out.println(index);

}

});

}

newFixedThreadPool:

public static void main(String[] args) {

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

for (int i = 0; i < 10; i++) {

final int index = i;

fixedThreadPool.execute(new Runnable() {

public void run() {

try {

System.out.println(index);

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

}

}

定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors().

newScheduleThreadPool()

public static void main(String[] args) {

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

for (int i = 0; i < 10; i++) {

scheduledThreadPool.schedule(new Runnable() {

public void run() {

System.out.println(“delay 3 seconds”);

}

}, 3, TimeUnit.SECONDS);

}

}

newSingleThreadExecutor

按顺序执行线程，某个时间段只能有一个线程存在，一个线程死掉，另一个线程会补上

public static void main(String[] args) {

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

for (int i = 0; i < 10; i++) {

final int index = i;

singleThreadExecutor.execute(new Runnable() {

public void run() {

/* System.out.println(index);*/

try {

System.out.println(index);

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

}

}

线程池Demo

package thread.demo.test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

class MyThread extends Thread{

public void run(){

System.out.println(Thread.currentThread().getName()+“is running”);

}

}

//class MyThread1 implements Runnable{

// public void run(){

// System.out.println("====");

// }

//}

public class ThreadPoolDemo {

/**

  • @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

// ExecutorService pool=Executors.newFixedThreadPool(3);

Thread t1=new MyThread();

Thread t2=new MyThread();

Thread t3=new MyThread();

Thread t4=new MyThread();

Thread t5=new MyThread();

// pool.execute(t1);

// pool.execute(t2);

// pool.execute(t3);

// pool.execute(t4);

// pool.execute(t5);

// pool.shutdown();

/*

  • output:

  • pool-1-thread-2is running

  • pool-1-thread-3is running

  • pool-1-thread-1is running

  • pool-1-thread-3is running

  • pool-1-thread-2is running

*/

// ExecutorService pool1=Executors.newCachedThreadPool();

// pool1.execute(t1);

// pool1.execute(t2);

// pool1.execute(t3);

// pool1.execute(t4);

// pool1.execute(t5);

// pool1.shutdown();

/*

  • o Java开源项目【ali1024.coding.net/public/P7/Java/git】 utput:

  • pool-2-thread-2is running

  • pool-2-thread-3is running

  • pool-2-thread-1is running

  • pool-2-thread-4is running

  • pool-2-thread-5is running

*/

// ExecutorService pool2=Executors.newSingleThreadExecutor();

// pool2.execute(t1);

// pool2.execute(t2);

// pool2.execute(t3);

// pool2.execute(t4);

// pool2.execute(t5);

// pool2.shutdown();

/*

  • OutPut:

  • pool-3-thread-1is running

  • pool-3-thread-1is running

  • pool-3-thread-1is running

  • pool-3-thread-1is running

  • pool-3-thread-1is running

*/

ExecutorService pool3=Executors.newScheduledThreadPool(1);

pool3.execute(new Runnable(){

public void run(){

System.out.println(Thread.currentThread().getName()+"====");

}

});

pool3.execute(new Runnable(){

public void run(){

System.out.println(Thread.currentThread().getName()+"~~~~");

}

});

pool3.shutdown();

/*

  • output:

  • pool-3-thread-1====

  • pool-3-thread-1~~~~

*/

}

最后

分布式技术专题+面试解析+相关的手写和学习的笔记pdf

还有更多Java笔记分享如下：

image

g

  • pool-3-thread-1is running

  • pool-3-thread-1is running

*/

ExecutorService pool3=Executors.newScheduledThreadPool(1);

pool3.execute(new Runnable(){

public void run(){

System.out.println(Thread.currentThread().getName()+"====");

}

});

pool3.execute(new Runnable(){

public void run(){

System.out.println(Thread.currentThread().getName()+"~~~~");

}

});

pool3.shutdown();

/*

  • output:

  • pool-3-thread-1====

  • pool-3-thread-1~~~~

*/

}

最后

分布式技术专题+面试解析+相关的手写和学习的笔记pdf

还有更多Java笔记分享如下：

[外链图片转存中…(img-07929S7r-1650173249021)]

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值