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

那么我们来看看多线程是怎么使用的

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及笔记，如若皆是你所需要的，那么都可发送给你！