【Java高级编程】Java多线程学习笔记
Java 多线程
1.多线程创建
方法1：通过 继承 thread 类
[子线程代码] MyThread.java
package example01_thread;
public class MyThread extends Thread {
@Override
public void run() {
// super.run();
for (int i = 0; i <= 1000; i++) {
System.out.println("===> 子线程 " + i);
}
}
}
[主线程代码] Test.java
package example01_thread;
public class Test {
public static void main(String[] args) {
MyThread myThread = new MyThread();
//myThread.run(); //方法调用，单线程。
myThread.start(); // 启动线程，多线程。 这个.statr() 继承自Thread类
for (int i = 0; i <= 1000; i++) {
System.out.println("===> 主线程 " + i);
}
}
}
[运行结果]
方法2：通过 实现 Runnable 接口
[子线程代码] MyRunnable.java
package example02_runnable;
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 1000; i++) {
System.out.println("===> 子线程 " + i);
}
}
}
[主线程代码] Test2.java
package example02_runnable;
public class Test2 {
public static void main(String[] args) {
Runnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
for (int i = 0; i <= 1000; i++) {
System.out.println("===> 主线程 " + i);
}
}
}
[运行结果]
2.线程中的相关方法
（1）设置优先级 setPrlorty()
优先级可以用从1到10的范围指定。10表示最高优先级（Thread.MAX_PRIORITY），1表示最低优先级（Thread.MIN_PRIORITY），5是普通优先级（Thread.NORM_PRIORITY，默认）。
优先级不能超出1-10的取值范围，否则抛出IllegalArgumentException
效果受操作系统影响，可能存在无效情况,因此不要有业务逻辑依赖于线程优先级，结果会无法预期
- Thread.setPriority()用来设定线程的优先级
- 在线程 start 方法被调用之前，线程的优先级应该被设定
- 线程的优先级不能超过所属线程组的优先级，即可以通过控制线程组的优先级，来控制线程组下线程的最大优先级
- 线程的优先级未设定时，默认所属的线程组的优先级
- 未指定线程优先级时，所有线程都携带普通优先级
- 优先级最高的线程在执行时被给予优先，最终由 CPU 调度程序决定哪一个线程被执行
- 与线程池中等待运行机会的线程相比，当前正在运行的线程可能总是拥有更高的优先级
- 高优先级线程不一定先于低优先级的线程运行。
[子线程代码] MyThread3.java
package example03_priority;
public class MyThread3 extends Thread{
public MyThread3(String name){
super.setName(name); //设置线程名字
}
@Override
public void run() {
//super.run();
for(int i = 0;i<=1000;i++){
System.out.println("===> 子线程 " +super.getName() + " "+ i);
}
}
}
[主线程代码] Test3.java (未设置线程优先级)
package example03_priority;
public class Test3 {
public static void main(String[] args) {
MyThread3 mt1 = new MyThread3("A");
MyThread3 mt2 = new MyThread3("B");
mt1.start();
mt2.start();
}
}
[运行结果]
[主线程代码] Test3.java (设置线程优先级)
package example03_priority;
public class Test3 {
public static void main(String[] args) {
MyThread3 mt1 = new MyThread3("A");
MyThread3 mt2 = new MyThread3("B");
mt1.setPriority(1);
mt2.setPriority(10);
mt1.start();
mt2.start();
}
}
[运行结果]
（2）设置睡眠 sleep()
sleep，每隔x时间 去执行一个y操作。参数单位：毫秒
package example04_sleep;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyThread4 extends Thread{
@Override
public void run() {
//让子系统不停的显示系统当前时间
while(true){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = new Date();
System.out.println(sdf.format(d));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
MyThread4 mt = new MyThread4();
mt.start();
}
}
等待子线程执行完毕 join()
让主线程等待当前执行中子线程执行完毕。
[子线程代码]MyThread5.java
package example05_join;
public class MyThread5 extends Thread{
@Override
public void run() {
// super.run();
for(int i = 0;i<=1000;i++){
System.out.println("===> 子线程 " + i);
}
}
}
[主线程代码]Test5.java
package example05_join;
public class Test {
public static void main(String[] args) {
MyThread5 myThread5 = new MyThread5();
myThread5.start();
for(int i = 0;i<=100;i++){
System.out.println("===> 主线程 " + i);
}
try {
myThread5.join(); //此时让主线程等待子线程执行完毕，再继续执行
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("主线程执行完毕");
}
}
让出CPU资源，让其他线程执行 yield()
让行，不代表不执行。具体谁先进行，依然由CPU决定，不能完全确定
[子线程代码]MyThread6.java
package example06_yield;
public class MyThread6 extends Thread {
public MyThread6(String name) {
super.setName(name);
}
@Override
public void run() {
// super.run();
for (int i = 0; i <= 500; i++) {
System.out.println(super.getName() + "：" + i);
if (i % 10 == 0) {
Thread.yield();
}
}
}
}
[主线程代码]Test6.java
package example06_yield;
import example04_sleep.yield.MyThread6;
public class Test6 {
public static void main(String[] args) {
MyThread6 mt1 = new MyThread6("A");
MyThread6 mt2 = new MyThread6("B");
mt1.start();
mt2.start();
}
}
[运行结果截图]
正如上图所见，让行是开发者设定的希望情况，但是并不代表一定成功让行。最终的决定权还是由CPU来决定
打断线程（尤其是正在睡眠中的线程） interrupt
[子线程代码]MyThread6.java
package example07.interrupt;
public class MyThread7 extends Thread{
@Override
public void run() {
// super.run();
System.out.println("线程即将进行休眠");
try{
Thread.sleep(1000000);
}catch (InterruptedException e){
// e.printStackTrace();
System.out.println("异常：线程休眠被打断");
}
System.out.println("线程被激活");
}
}
[主线程代码]Test6.java
package example07.interrupt;
public class Test7 {
public static void main(String[] args) {
MyThread7 myThread7 = new MyThread7();
myThread7.start();
for(int i = 0;i<=100;i++){
System.out.println("===> 主线程 " + i);
}
myThread7.interrupt(); // 打断正在休眠中的子线程
}
}
[运行结果截图]
3.线程同步
线程同步：当多个线程共享同一个资源的时候，我们可以在某一个线程访问到这个资源的时候，将这个资源暂时封锁
等待当前线程执行结束，解锁该资源，其他线程才可以来继续执行。
总结：等待其他线程释放锁
目的：让线程更加安全
下面以银行取钱案例说明。
[账户对象]Account.java
package example08_sync;
public class Account {
private double balance;
public Account(double balance){
this.balance = balance;
}
public void getMoney(){ //在方法声明上添加synchronized关键字 一旦执行到该方法，瞬间锁定对象Account
if(this.balance<=0){return;}
System.out.println("即将取走1000，目前金额为："+this.balance);
this.balance -= 1000;
System.out.println("成功取走1000，目前金额为："+this.balance);
}
}
[取钱线程]GetMoneyThread.java
package example08_sync;
public class GetMoneyThread extends Thread{
private Account acc;
public GetMoneyThread(Account acc){
this.acc = acc;
}
@Override
public void run() {
acc.getMoney();
}
}
[测试类]Test8.java
package example08_sync;
public class Test8 {
public static void main(String[] args) {
//创建账户
Account account = new Account(1000);
//创建ATM线程
GetMoneyThread atm = new GetMoneyThread(account);
//创建柜台线程
GetMoneyThread table = new GetMoneyThread(account);
//取钱
atm.start();
table.start();
}
}
[运行结果]
可以发现，设置的余额不足拦截（if(this.balance<=0){return;}）没有生效，出现了账户余额为负数情况。
为避免这些情况的出现，因此需要线程同步。即将多个处理统一资源的线程，进行队列化管理（锁）
实现线程同步的方法
方法1：在方法声明上添加一个synchronized关键字
package example08_sync;
public class Account {
private double balance;
public Account(double balance){
this.balance = balance;
}
public synchronized void getMoney(){ //在方法声明上添加synchronized关键字 一旦执行到该方法，瞬间锁定对象Account
if(this.balance<=0){return;}
System.out.println("即将取走1000，目前金额为："+this.balance);
this.balance -= 1000;
System.out.println("成功取走1000，目前金额为："+this.balance);
}
}
方法2：在方法内部添加一个synchronized关键字
package example08_sync;
public class Account {
private double balance;
public Account(double balance){
this.balance = balance;
}
public synchronized void getMoney(){ //在方法声明上添加synchronized关键字 一旦执行到该方法，瞬间锁定对象Account
synchronized (this){
if(this.balance<=0){return;}
System.out.println("即将取走1000，目前金额为："+this.balance);
this.balance -= 1000;
System.out.println("成功取走1000，目前金额为："+this.balance);
}
}
}
方法3：手动上锁
该方法用的最少，因为容易出现忘记解锁。
package example08_sync;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Account {
private double balance;
private Lock lock = new ReentrantLock(); //创建锁
public Account(double balance){
this.balance = balance;
}
public void getMoney(){ //在方法声明上添加synchronized关键字 一旦执行到该方法，瞬间锁定对象Account
lock.lock(); // 上锁
if(this.balance<=0){return;}
System.out.println("即将取走1000，目前金额为："+this.balance);
this.balance -= 1000;
System.out.println("成功取走1000，目前金额为："+this.balance);
lock.unlock(); //解锁
}
}
死锁
线程同步时最容易发生的问题
eg：线程A锁定资源1后，等待访问资源2；线程2锁定资源2后，等待访问资源1。
[资源对象] ResourceObjec.java
package example09_dead;
public class ResourceObject {
public static Object obj1 = new Object();
public static Object obj2 = new Object();
}
[线程1] DeadLock1.java
package example09_dead;
public class DeadLock1 extends Thread{
@Override
public void run() {
// super.run();
synchronized (ResourceObject.obj1){
System.out.println("线程1 第一个资源锁定");
try{
//通过休眠使CPU去执行其他线程
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (ResourceObject.obj2){
System.out.println("线程1 第二个资源锁定");
System.out.println("线程1执行完毕");
}
}
}
}
[线程2] DeadLock2.java
package example09_dead;
public class DeadLock2 extends Thread{
@Override
public void run() {
// super.run();
synchronized (ResourceObject.obj2){
System.out.println("线程2 第二个资源锁定");
try{
//通过休眠使CPU去执行其他线程
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (ResourceObject.obj1){
System.out.println("线程2 第一个资源锁定");
System.out.println("线程2执行完毕");
}
}
}
}
[测试] Test9.java
package example09_dead;
public class Test9 {
public static void main(String[] args) {
DeadLock1 dl1 = new DeadLock1();
DeadLock2 dl2 = new DeadLock2();
dl1.start();
dl2.start();
}
}
[运行结果]
线程的生命周期
- [1]创建线程
- ---[start()]--> [2]就绪状态
- ---[CPU调度]--> [3]运行状态
- ---[stop()]--> (跳转到4)
- ---[IO操作、sleep]--> 阻塞状态 ---[IO结束、sleep()结束]--> （跳转到2）
- --------------> [4]消亡状态
生产者消费者模型
案例：实现对视频进行审查，如果是不良视频，则对视频进行删除
[视频对象] Video.java
package example10_check;
public class Video {
private String name;
public Video (String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
[检查视频] CheckVideo.java
package example10_check;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
public class CheckVideo extends Thread{
private static AtomicInteger i = new AtomicInteger(); //AtomicInteger原子型整数。特点：线程安全 效果等同于 int i = 0，但是比int i = 0 更安全。
//将视频添加到缓冲区（队列）
private BlockingQueue<Video> videos;
public CheckVideo(BlockingQueue<Video> videos){
this.videos = videos;
}
@Override
public void run() {
while (true){
String name = "不良视频"+i.incrementAndGet();// 相当于i++
Video v = new Video(name);
//将视频添加到队列
try {
System.out.println("发现不良视频"+name);
videos.put(v);
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
[删除视频] DelVideo.java
package example10_check;
import java.util.TreeMap;
import java.util.concurrent.BlockingQueue;
public class DelVideo extends Thread {
private BlockingQueue<Video> videos;
public DelVideo(BlockingQueue<Video> videos){
this.videos = videos;
}
@Override
public void run() {
while(true){
try{
Video video = videos.take();
System.out.println("删除不良视频"+video.getName());
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
[测试] Test10.java
package example10_check;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class Test10 {
public static void main(String[] args) {
BlockingQueue<Video> videos = new LinkedBlockingQueue<Video>();
//创建3个检查视频的线程
CheckVideo ck1 = new CheckVideo(videos);
CheckVideo ck2 = new CheckVideo(videos);
CheckVideo ck3 = new CheckVideo(videos);
//创建两个删除视频的线程
DelVideo d1 = new DelVideo(videos);
DelVideo d2 = new DelVideo(videos);
ck1.start();
ck2.start();
ck3.start();
d1.start();
d2.start();
}
}
[运行结果]
【Java高级编程】Java多线程学习笔记的更多相关文章
- 《Java并发编程实战》学习笔记 线程安全、共享对象和组合对象
Java Concurrency in Practice,一本完美的Java并发参考手册. 查看豆瓣读书 推荐:InfoQ迷你书<Java并发编程的艺术> 第一章 介绍 线程的优势:充分利 ...
- 《Java并发编程实战》学习笔记
第2章 线程安全性 正确性: 某个类的行为与其规范完全一致. 2.1线程安全: 当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程将如何交替执行,并且在主调代码中不需要任何额外的同步或 ...
- 《Java并发编程实战》学习笔记 任务执行和取消关闭
查看豆瓣读书 第六章 任务执行 大多数并发应用程序是围绕执行任务进行管理的.设计任务时,要为任务设计一个清晰的任务边界,并配合一个明确的任务执行策略.任务最好是独立的,因为这会提高并发度.大多数服务器 ...
- java多线程学习笔记——详细
一.线程类 1.新建状态(New):新创建了一个线程对象. 2.就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法.该状态的线程位于可运行线程池中, ...
- JAVA多线程学习笔记（1）
JAVA多线程学习笔记(1) 由于笔者使用markdown格式书写,后续copy到blog可能存在格式不美观的问题,本文的.mk文件已经上传到个人的github,会进行同步更新.github传送门 一 ...
- java进阶-多线程学习笔记
多线程学习笔记 1.什么是线程 操作系统中 打开一个程序就是一个进程 一个进程可以创建多个线程 现在系统中 系统调度的最小单元是线程 2.多线程有什么用? 发挥多核CPU的优势 如果使用多线程 将计算 ...
- Java多线程学习笔记（一）——多线程实现和安全问题
1. 线程.进程.多线程: 进程是正在执行的程序,线程是进程中的代码执行,多线程就是在一个进程中有多个线程同时执行不同的任务,就像QQ,既可以开视频,又可以同时打字聊天. 2.线程的特点: 1.运行任 ...
- 图灵学院JAVA互联网架构师专题学习笔记
图灵学院JAVA互联网架构师专题学习笔记 下载链接:链接: https://pan.baidu.com/s/1xbxDzmnQudnYtMt5Ce1ONQ 密码: fbdj如果失效联系v:itit11 ...
- Java并发编程的艺术读书笔记(2)-并发编程模型
title: Java并发编程的艺术读书笔记(2)-并发编程模型 date: 2017-05-05 23:37:20 tags: ['多线程','并发'] categories: 读书笔记 --- 1 ...
- Java并发编程的艺术读书笔记(1)-并发编程的挑战
title: Java并发编程的艺术读书笔记(1)-并发编程的挑战 date: 2017-05-03 23:28:45 tags: ['多线程','并发'] categories: 读书笔记 --- ...
随机推荐
- localStorage 、 sessionStoarge 和 cokies 的区别
1. 三者的概念 1.1 cookies Cookie,有时也用其复数形式 Cookies.类型为"小型文本文件",是某些网站为了辨别用户身份,进行Session(会话)跟踪而储存 ...
- Excel488个函数一览
目录: 常用函数 Web 函数 财务函数 查找和引用函数 多维数据集函数 工程函数 兼容性函数 逻辑函数 日期和时间函数 数据库函数 数学和三角函数 统计函数 文本函数 信息函数 与加载项一起安装的用 ...
- 使用 Cilium 作为网络插件部署 K8s + KubeSphere
Cilium 简介 Cilium 是一个用于容器网络领域的开源项目,主要是面向容器而使用,用于提供并透明地保护应用程序工作负载(如应用程序容器或进程)之间的网络连接和负载均衡. Cilium 在第 3 ...
- Vue最受欢迎的七大跨端框架，你都用过哪几个？
随着移动互联网的快速发展,开发者们不仅需要为Web开发,还需要兼顾iOS.Android.小程序等多个平台.这让"跨端开发"成为了炙手可热的话题.而基于Vue的跨端框架凭借其优异的 ...
- 链表反转（反转全部，前n个，中间）
链表反转 反转全部 // 迭代 struct ListNode *reverseList(struct ListNode *head) { struct ListNode *pre = NULL; s ...
- 史上最全ThreadLocal 详解
概述 线程本地变量.当使用 ThreadLocal 维护变量时, ThreadLocal 为每个使用该变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程. 每个 ...
- spring生态体系
spring boot使用默认开发配置来实现快速开发spring xd用来简化大数据应用开发spring cloud为分布式系统开发提供工具集spring data对主流的关系型和nosql数据库的支 ...
- NOIP2024模拟12：孤帆远影
NOIP2024模拟12:孤帆远影 听了机房同学的讨论,于是T1死磕冒泡和逆序对做法.最后只得了40pts. 思想对了,但不是自己的做法. 还是要坚持自己想,坚持自己可以想出来,不要被任何人带偏. T ...
- 全网最适合入门的面向对象编程教程：58 Python字符串与序列化-序列化Web对象的定义与实现
全网最适合入门的面向对象编程教程:58 Python 字符串与序列化-序列化 Web 对象的定义与实现 摘要: 如果我们要在不同的编程语言之间传递对象,就必须把对象序列化为标准格式,比如XML\YAM ...
- 解决MobaXterm自动断开连接，亲测有效~
场景: 使用MobaXterm工具通过SSH连接Linux服务器,如果一段时间没有操作,MobaXterm会把连接自动断开,这个设定很是不方便.通过更改下面的设置可以使SSH保持长连接,不会自动断开.