带你从零学大数据系列之Java篇---第二十章多线程基础_千峰教育多线程(2)

2401_84181626

已于 2024-05-01 05:28:04 修改

阅读量657

点赞数 22

分类专栏：程序员文章标签： java 大数据 jvm

于 2024-05-01 05:28:03 首次发布

本文链接：https://blog.csdn.net/2401_84181626/article/details/138363986

版权

程序员专栏收录该内容

153 篇文章 0 订阅

订阅专栏

    // Runnable接口的匿名实现类
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out,println("子线程处理的逻辑");
        }
    };
    // 实例化线程对象
    Thread thread = new Thread(runnable);
}

}


**20.3.1.3. 优缺点对比**


* 继承的方式： 优点在于可读性比较强， 缺点在于不够灵活。 如果要定制一个线程， 就必须要继承自Thread类， 可能会影响原有的继承体系。
* 接口的方式： 优点在于灵活， 并且不会影响一个类的继承体系。 缺点在于可读性较差。



> 
>  后面课程中， 用的比较多的方式是使用接口的方式。 
> 


**20.3.2. 线程名字的设置**


每一个线程， 都有一个名字。 如果在实例化线程的时候不去设定名字， 那么这个线程会拥有一个默认的名字。


* 设置线程的名字， 使用方法 setName(String name)

/**

@Description
*/
public class Program {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
System.out.println(“子线程的逻辑”)；
});
// 设置线程的名字
thread.setName(“子线程的名字”);
}
}


* Thread类对象， 在进行实例化的时候， 可以同时设置线程的名字。

/**

@Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Thread thread = new Thread(() -> {}, “线程的名字”);
}
}


* 如果使用继承Thread类的方式进行的实例化， 可以添加一个构造方法， 进行实例化对象的同时进行名称的设置。 在构造方法中， 使用 super(String) 进行父类方法的调用。

/**

@Description
*/
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}

@Override
public void run() {
System.out.println(“子线程的逻辑”);
}
}


设置线程名字， 可以使用上述三种方式， 但是获取线程线程的名字， 只有一个方法， 就是 getName()

/**

@Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Thread thread = new Thread(() -> {}, “线程的名字”);
```
 System.out.println(thread.getName());
```
}
}


**20.3.3. 线程的执行**


线程对象刚刚被实例化的时候， 线程处于新生态。 如果需要让这个线程执行他的任务， 需要调用 start() 方法， 使线程进入到就绪态， 争抢CPU时间片。


**注意事项：**


**使用start()方法， 不是run()方法！**


使用start方法， 会使得线程进入到就绪态， 开始争抢CPU时间片， 实现并发的任务。 如果直接调用run方法， 那么任务将会直接在当前线程中执行， 并不会实现并发！

/**

@Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Thread thread = new Thread(() -> {}, “线程的名字”);
thread.start();
}
}


**20.3.4. 线程的礼让**


线程礼让， 就是是的当前已经抢到CPU资源的正在运行的线程， 释放自己持有的CPU资源， 回到就绪状态， 重新参与CPU时间片的争抢。

/**

@Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Runnable runnable = () -> {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " : " + i);
if (i == 5) {
Thread.yield();
}
}
};
// 实例化两个线程，处理的逻辑完全相同
Thread thread0 = new Thread(runnable, “t0”);
Thread thread1 = new Thread(runnable, “t1”);
```
 thread0.start();
 thread1.start();
```
}
}


**20.3.5. 线程的休眠**


线程休眠， 就是让当前的线程休眠指定的时间。 休眠的线程进入到阻塞状态， 直到休眠结束。 阻塞的线程， 不参与CPU时间片的争抢。


注: 线程休眠的时间单位是毫秒。

/**

@Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Runnable runnable = () -> {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
// 线程休眠
Thread.sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
};
// 实例化两个线程，处理的逻辑完全相同
Thread thread0 = new Thread(runnable, “t0”);
Thread thread1 = new Thread(runnable, “t1”);
```
 thread0.start();
 thread1.start();
```
}
}


**20.3.6. 线程的合并**


将一个线程中的任务， 合并入到另外一个线程中执行， 此时， 合并进来的线程有限执行。 类似于： 插队。

/**

@Description
*/
public class Program {
// 记录余票数量
static int ticketCount = 100;

public static void main(String[] args) {
// 循环卖票
while (ticketCount > 0) {
// 票数 -1
System.out.println("窗口卖出一张票给散客，剩余: " + --ticketCount);
// 卖出 30 张
if (ticketCount == 70) {
// 实例化⼀个 VIP 团体线程
Thread vip = new Thread(() -> {
for (int i = 0; i < 50; i++) {
System.out.println("窗口卖出一张票给VIP团队，剩余: " + --ticketCount);
}
});
// 先开启
vip.start();
// 再合并
try {
vip.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Thread thread = new Thread(runnable);
thread.start();
}
}


**20.3.7. 线程的优先级设置**


设置线程的优先级， 可以决定这个线程能够抢到CPU时间片的概率。 线程的优先级范围在 [1, 10]， 默认的优先级是5。 数值越高， 优先级越高。 但是要注意， 并不是优先级高的线程一定能抢到CPU时间片， 也不是优先级的线程一定抢不到CPU时间片。 线程的优先级只是决定了这个线程能够抢到CPU时间片的概率。 即便是优先级最低的线程， 依然可以抢到CPU时间片。

/**

@Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Runnable runnable = () -> {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + " : " + i);
}
};
// 实例化两个线程，处理的逻辑完全相同
Thread thread0 = new Thread(runnable, “t0”);
Thread thread1 = new Thread(runnable, “t1”);
```
 // 设置线程的优先级， 必须在这个线程启动之前
 thread0.setPriority(1);
 thread1.setPriority(10);
 
 thread0.start();
 thread1.start();
```
}
}


**20.3.8. 当前线程的获取**


* Thread.currentThread() : 可以用在任意的位置， 获取当前的线程。
* 如果是Thread的子类， 可以在子类中， 使用this获取到当前的线程。


**20.3.9. 守护线程**


守护线程， 又叫后台线程。 是一个运行在后台， 并且会和前台线程争抢CPU时间片的线程。


* 守护线程依然会和前台线程争抢CPU时间片， 实现并发的任务。
* 在一个进程中， 如果所有的前台线程都结束了， 后台线程即便任务没有执行结束， 也会自动结束。

/**

@Description
*/
public class Program {
public static void main(String[] args) {
// 实例化一个线程
Thread thread = new Thread(() -> {
while (true) {
System.out.println(“守护线程在运行”)；
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 将一个线程设置为守护线程
thread.setDaemon(true);
// 开启线程
thread.start();

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

);

[外链图片转存中…(img-neulchDl-1714512434959)]
[外链图片转存中…(img-ppayjzJl-1714512434960)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

2401_84181626

关注

22
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
带你从零学大数据系列之Java篇---第二十章多线程基础_千峰教育多线程(2)

System.out.println("窗口卖出一张票给VIP团队，剩余: " + --ticketCount);// 实例化两个线程，处理的逻辑完全相同。// 实例化两个线程，处理的逻辑完全相同。// 实例化两个线程，处理的逻辑完全相同。// 使用接口的方式进行线程的实例化。// 使用接口的方式进行线程的实例化。// 使用接口的方式进行线程的实例化。// 使用接口的方式进行线程的实例化。// 实例化⼀个 VIP 团体线程。// 卖出 30 张。
复制链接

扫一扫