那么我们来看看多线程是怎么使用的
package com.geoji.thread;
//一个简单的多线程案例
public class ThreadDome_01 {
public static void main(String[] args) throws Exception {
Thread t0 = Thread.currentThread();
System.out.println(t0.getId() + “main”);
thread1 t = new thread1();
t.start();
thread2 t2 = new thread2();
// 将线程2设置为守护线程
t2.setDaemon(true);
t2.start();
Runnable t3 = new thread3();
t3.run();
// t.setPriority(Thread.MAX_PRIORITY);
// ((Thread) t3).setPriority(Thread.MIN_PRIORITY);
// t.join();//等t线程结束后再执行下面的代码
System.out.println(“asda”);
}
}
// 第一个线程
// 继承Thread类 重写run方法
class thread1 extends Thread {
@Override
public void run() {
Thread t1 = Thread.currentThread();
for (int i = 0; i < 100; i++) {
System.out.println(t1.getId() + “第一个线程” + i);
}
}
}
// 第二个线程
// 继承Thread类 重写run方法
class thread2 extends Thread {
@Override
public void run() {
Thread t2 = Thread.currentThread();
for (int i = 0; i < 2000; i++) {
System.out.println(t2.getId() + “第二个线程” + i);
}
}
}
// runnable接口重写run方法
// 第三个线程
class thread3 implements Runnable {
@Override
public void run() {
Thread t3 = Thread.currentThread();
for (int i = 0; i < 100; i++) {
System.out.println(t3.getId() + “第三个线程” + i);
}
}
}
第一种、对象锁
- 问题描述:两个人合租,小红和小明 早上起床,小红先去厕所刷牙,刷完牙出来,小明再去刷牙 小红去上厕所,小红上完厕所出来,小明再去上厕所
话不多说,我们直接上代码,这是一个线程实体类Roommate .java
package com.geoji.thread;
/**
-
同步线程(谁拿到这个类谁去执行代码)
-
对象锁(给类加把锁,让类去控制线程的出入)
-
synchronized同步方法
*/
public class Roommate extends Thread {
static Object tolite = new Object();// 厕所管理员
Roommate(String name) {
super(name);
}
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (tolite) {
// 及时的让释放锁也是很关键
if (“小明”.equals(Thread.currentThread().getName())) {
brush();// 小明去刷牙
try {
tolite.wait();//将锁释放掉
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}// 释放掉锁,此时小明进入等待状态
wc();
tolite.notify();// 唤醒小红
} else {
brush();// 小红刷牙
try {
tolite.notify();// 唤醒小明
tolite.wait();// 小红释放掉锁,此时小红进入等待状态
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
wc();
}
}
}
// 刷牙
public void brush() {
System.out.println(Thread.currentThread().getName() + “刚进去厕所刷牙”);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + “刷完牙出来了”);
}
// 上厕所
public void wc() {
System.out.println(Thread.currentThread().getName() + “刚进去厕所蹲马桶”);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + “蹲完马桶出来了”);
}
}
接着是他的启动类RoommateRun.java
package com.geoji.thread;
/*
- 同步代码块
*/
public class RoommateRun {
public static void main(String[] args) {
Thread t1 = new Roommate(“小红”);
Thread t2 = new Roommate(“小明”);
t1.start();
t2.start();
}
}
运行结果:
小明刚进去厕所刷牙
小明刷完牙出来了
小红刚进去厕所刷牙
小红刷完牙出来了
小明刚进去厕所蹲马桶
小明蹲完马桶出来了
小红刚进去厕所蹲马桶
小红蹲完马桶出来了
- 问题描述:有两个儿子,分别叫大明和小明,今年暑假妈妈在冰箱里买了50个雪糕,让两个儿子去吃,写个程序描述这一问题,并且统计出两个人各吃了多少。
同样话不多说我们直接上代码;这是一个线程实体类Son .java
package com.geoji.thread;
/*
-
同步代码块
-
方法锁(谁拿到了这个方法谁去执行)
*/
public class Son implements Runnable{
private int bigNum;//描述大明吃了多少个雪糕
private int smallNum;//描述小明吃了多少个雪糕
private int count=50;//雪糕总数
private boolean isGoon=true;//用来控制声明时候结束吃雪糕
//吃雪糕的方法
public synchronized void eat(){
if(count<=0){
isGoon=false;
return;
}
count–;
if(“大明”.equals(Thread.currentThread().getName())){
bigNum++;
System.out.println(“大明吃了第”+(50-this.count)+“根雪糕”);
}else{
smallNum++;
System.out.println(“小明吃了第”+(50-this.count)+“根雪糕”);
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void run() {
// TODO Auto-generated method stub
while(isGoon){
eat();
}
}
public void show(){
System.out.println(“大明吃了”+bigNum);
System.out.println(“小明吃了”+smallNum);
}
}
接着是他的启动类SonRun.java
package com.geoji.thread;
public class SonRun {
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) {
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);
} ca
必看视频!获取2024年最新Java开发全套学习资料 备注Java
tch (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 {
结局:总结+分享
看完美团、字节、腾讯这三家的一二三面试问题,是不是感觉问的特别多,可能咱们真的又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。
开篇有提及我可是足足背下了Java互联网工程师面试1000题,多少还是有点用的呢,换汤不换药,不管面试官怎么问你,抓住本质即可!能读到此处的都是真爱
- Java互联网工程师面试1000题
而且从上面三家来看,算法与数据结构是必备不可少的呀,因此我建议大家可以去刷刷这本左程云大佬著作的 《程序员代码面试指南 IT名企算法与数据结构题目最优解》,里面近200道真实出现过的经典代码面试题。
- 程序员代码面试指南–IT名企算法与数据结构题目最优解
- 其余像设计模式,建议可以看看下面这4份PDF(已经整理)
- 更多的Java面试学习笔记如下,关于面试这一块,我额外细分出Java基础-中级-高级开发的面试+解析,以及调优笔记等等等。。。
以上所提及的全部Java面试学习的PDF及笔记,如若皆是你所需要的,那么都可发送给你!
(int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
/* System.out.println(index);*/
try {
结局:总结+分享
看完美团、字节、腾讯这三家的一二三面试问题,是不是感觉问的特别多,可能咱们真的又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。
开篇有提及我可是足足背下了Java互联网工程师面试1000题,多少还是有点用的呢,换汤不换药,不管面试官怎么问你,抓住本质即可!能读到此处的都是真爱
- Java互联网工程师面试1000题
[外链图片转存中…(img-CPUe9RCt-1716464408243)]
而且从上面三家来看,算法与数据结构是必备不可少的呀,因此我建议大家可以去刷刷这本左程云大佬著作的 《程序员代码面试指南 IT名企算法与数据结构题目最优解》,里面近200道真实出现过的经典代码面试题。
- 程序员代码面试指南–IT名企算法与数据结构题目最优解
[外链图片转存中…(img-vRta9IMd-1716464408244)]
- 其余像设计模式,建议可以看看下面这4份PDF(已经整理)
[外链图片转存中…(img-VUi4JuPE-1716464408244)]
- 更多的Java面试学习笔记如下,关于面试这一块,我额外细分出Java基础-中级-高级开发的面试+解析,以及调优笔记等等等。。。
[外链图片转存中…(img-43imJ7kp-1716464408244)]
以上所提及的全部Java面试学习的PDF及笔记,如若皆是你所需要的,那么都可发送给你!