Java多线程精讲(非高并发-授课专用)附synchronized
2023-09-14 09:14:16 时间
Java多线程精讲(非高并发-授课专用)
目录
程序，进程，线程的基本概念
程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。
进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。——生命周期。
线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。
即：线程《线程（一个程序可以有多个线程）
程序：静态的代码 进程：动态执行的程序
线程：进程中要同时干几件事时，每一件事的执行路径成为线程。
附：
并行：多个CPU同时执行多个任务，比如:多个人同时做不同的事。
并发：一个CPU（采用时间片）同时执行多个任务，比如秒杀平台，多个人做同件事
线程的相关API
//获取当前线程的名字
currentThread();静态方法，返回执行当前代码的线程
Thread.currentThread().getName();获取当前线程的名字
Thread.currentThread().setName();设置当前线程的名字
sleep(long millitime);线程休眠一段时间
start();1.启动当前线程2.调用线程中的run方法
run();通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
join();线程等待·卡死的等待。
isAlive();判断当前线程是否存活start与run的区别
用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，run方法运行结束，此线程随即终止。
函数测试demo：
package test;
/**
*
* @author laoshifu
* @date 2021年12月5日
*
*/
public class Main {
public static void main(String[] args) throws InterruptedException {
//修改线程名城
Thread.currentThread().setName("superMan");
//获取线程名称
String name = Thread.currentThread().getName();
System.out.println(name);
//当前线程是否存在
boolean b = Thread.currentThread().isAlive();
System.out.println(b);
//创建多线程
Thread t = new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
};
//启动多线程
t.run();
//线程等待
Thread.currentThread().join();
//休息
Thread.sleep(2000);
//某线程是否存在
System.out.println(t.isAlive());
}
}
创建线程（一）【new Thread()】
这里继承Thread类的方法是比较常用的一种，如果说你只是想起一条线程。没有什么其它特殊的要求，那么可以使用Thread
//创建多线程
Thread t = new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
};
//启动多线程
t.run();创建线程（二）【extends Thread】
package test;
public class Thread_test extends Thread{
@Override
public void run() {
currentThread().setName("orange");
for (int i = 0; i < 100; i++) {
System.out.println(currentThread().getName()+":"+i);
}
}
}
package test;
/**
* @author laoshifu
* @date 2021年12月5日
*/
public class Main {
public static void main(String[] args) {
Thread_test test = new Thread_test();
test.run();
}
}
}
创建线程（三）【implements Runnable】
采用Runnable也是非常常见的一种，我们只需要重写run方法即可。下面也来看个实例。
package test;
public class Thread_te implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Runnable"+":"+i);
}
}
}
package test;
/**
* @author laoshifu
* @date 2021年12月5日
*/
public class Main {
public static void main(String[] args) {
Thread t1 = new Thread(new Thread_te());
t1.start();
}
}}
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
线程无交互测试：【run】
package test;
/**
* @author laoshifu
* @date 2021年12月5日
*/
public class Main {
public static void main(String[] args) {
Thread_test test = new Thread_test();
test.run();
Thread_test2 test2 = new Thread_test2();
test2.run();
Thread t3 = new Thread(new Thread_te());
t3.start();
}
}
无交互
线程无交互测试：【start】
package test;
/**
* @author laoshifu
* @date 2021年12月5日
*/
public class Main {
public static void main(String[] args) {
Thread_test test = new Thread_test();
Thread_test2 test2 = new Thread_test2();
Thread t3 = new Thread(new Thread_te());
System.out.println("开启一");
test.start();
System.out.println("开启二");
test2.start();
System.out.println("开启三");
t3.start();
}
}
加强交互：【加上sleep休息时间
】
总结：
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
游戏编写：【王语嫣大战表哥·慕容复】
package test;
import java.util.Random;
import java.util.Scanner;
/**
* @author laoshifu
* @date 2021年12月5日
*/
public class Main {
static String name = "王语嫣";
static String bossName = "表哥·慕容复";
/**
* 王语嫣攻击力
*/
static int A_AC = 500;
/**
* 表哥·慕容复血量
*/
static int B_HP = 100000;
public static void main(String[] args) {
System.out.println("战斗开始");
System.out.println("**********************");
System.out.println("***1、增加10%战斗力****");
System.out.println("***2、BOSS血量增加10%**");
System.out.println("**********************");
new Thread() {
public void run() {
Random ra = new Random();
while (true) {
int Cut = A_AC + ra.nextInt(A_AC);
B_HP -= Cut;
String s = String.format("%s对%s造成%s点伤害,%s血量剩余%s", name, bossName, Cut, bossName, B_HP);
System.out.println(s);
if (B_HP <= 0) {
System.out.printf("终于干掉了%s，可以和段公子长相厮守了。", bossName);
//游戏停止
System.exit(0);
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
}.start();
new Thread() {
@SuppressWarnings("resource")
public void run() {
Scanner sc = new Scanner(System.in);
while (true) {
switch (sc.next()) {
case "1":
A_AC+=(A_AC/10);
System.out.println(name+"攻击增加10%，当前"+name+"攻击力"+A_AC);
break;
case "2":
B_HP+=(B_HP/10);
System.out.println(bossName+"血量增加10%，当前血量"+B_HP);
break;
default:
break;
}
}
};
}.start();
}
}
synchronized【Java】中使用的demo
没有synchronized的效果：
package Action;
public class syn {
static int count=10;
static Object lock=new Object();
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
if(count<=0) {
System.out.println("内部线程:结束");
break;
}
// synchronized(lock) {
count--;
System.out.println("内部线程:"+count);
// }
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}).start();
while (true) {
if(count<=0) {
System.out.println("外部线程:结束");
break;
}
// synchronized (lock) {
count--;
System.out.println("外部线程:"+count);
// }
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
很明显，在没有使用【锁】的时候数据出现了错误。
synchronized
有synchronized的效果:
package Action;
public class syn {
static int count=10;
static Object lock=new Object();
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
if(count<=0) {
System.out.println("内部线程:结束");
break;
}
synchronized(lock) {
count--;
System.out.println("内部线程:"+count);
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}).start();
while (true) {
if(count<=0) {
System.out.println("外部线程:结束");
break;
}
synchronized (lock) {
count--;
System.out.println("外部线程:"+count);
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
效果很明显，没有数据错误。
synchronized不仅可以修饰代码块，还可以修饰方法、实例对象、class对象。
如果锁的是类对象的话，尽管new多个实例对象，但他们仍然是属于同一个类依然会被锁住，即线程之间保证同步关系，以上的游戏demo可以使用【synchronized】锁定慕容复的血量。
希望可以使大家对【多线程】增加一定的理解。
欢迎一键三连。
相关文章
- Java实现洛谷 P1428 小鱼比可爱
- Java实现 蓝桥杯 历届试题 数字游戏
- Java实现 蓝桥杯VIP 算法训练 ALGO-16进制转换
- JAVA多线程实现简单的点名系统
- Java核心知识点学习----多线程并发之线程间的通信,notify,wait
- java核心知识点学习----多线程并发之线程同步
- 【JAVA】MacBook安装Java环境及eclipse
- Java多线程--让主线程等待所有子线程执行完毕
- java 多线程通信之管道流
- java多线程 -- Condition 控制线程通信
- Java多线程和并发基础面试问答
- Java多线程学习笔记 - 十二、并发工具
- Atitit 并发处理 go与 java对比较 目录 1. 并发编程的七个模型 线程，fp，actor，csp 数据级并行 Lambda1 2. 四种并发编程模型简介 多线程，callback
- Java并发编程实战：掌握多线程编程的交错优化和高效实践
- 【java】EJB(Enterprise Java Bean)概述
- Java学习路线-65：整合 SSM-Spring+SpringMVC+MyBatis
- JAVA编程：java环境安装和helloworld
- Java多线程与并发
- Java并发编程与高并发之多线程
- Java多线程的wait(),notify(),notifyAll()
- java面试题：多线程与并发
- java多线程与并发笔记
- Java多线程中常用的方法
- 【Java并发编程系列】全方位理解多线程几乎包含线程的所有操作哦