JavaSE——多线程
多线程（⭐⭐⭐⭐⭐）
实现多线程方式一：继承Thread类
-
方法介绍
方法名 说明 void run() 在线程开启后，此方法将被调用执行 void start() 使此线程开始执行，Java虚拟机会调用run方法 -
实现步骤
- 1定义一个类继承Thread类
- 2在类中重写run()方法
- 3用这个类创建对象
- 4用对象调用start 开启线程
代码演示
注意：直接调用run方法 不会开启线程
- 创建线程的类
public class MyThread extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 100; i++) {
System.out.println("我唱歌" + i);
}
}
}
- 测试类中使用线程
public class Demo02 {
public static void main(String[] args) {
// 1 写一个类继承Thread
//2 重写run方法
//3 用这个类创建对象
MyThread t1 = new MyThread();
//4 用对象调用start 开启线程
t1.start();
//再次创建一个线程
MyThread t2 = new MyThread();
//开启线程
t2.start();
}
}
Thread中的方法
构造方法：
- Thread()：空参数的构造方法。
- Thread(String name)：一个参数是字符串的构造方法，参数表示线程名字。
其它方法
- String getName()：获取线程名字。
- void setName(String name)：设置线程名字。
- static Thread currentThread()：获取当前正在执行的线程对象。
- static void sleep(long millis)：线程休眠，参数是休眠的毫秒值。
代码
- 实现两个子线程一个唱歌一个跳舞，主线程打篮球 如下：
Thread子类的代码
- 两个子类，一个唱歌，一个跳舞， 都写了空参 和有参构造，有参构造里可以传入一个字符串给线程命名
- 在run中，调用了getName方法获取了线程的名字
public class MyThread extends Thread {
public MyThread() {
}
public MyThread(String name) {
super(name);
}
@Override
public void run() {
super.run();
for (int i = 0; i < 100; i++) {
System.out.println("我唱歌" + i+"---"+getName());
}
}
}
class MyThread2 extends Thread {
public MyThread2() {
}
public MyThread2(String name) {
super(name);
}
@Override
public void run() {
super.run();
for (int i = 0; i < 100; i++) {
System.out.println("我跳舞" + i+"---"+getName());
}
}
}
测试代码
- 创建Thread对象的时候，传入了线程的名字 sing和dance
- 主线程for循环中打篮球，通过Thread.currentThread() 获取当前线程对象 然后getName()获取线程的名字
public class Demo05 {
public static void main(String[] args) {
// 1 写一个类继承Thread
//2 重写run方法
//3 用这个类创建对象
MyThread t1 = new MyThread("sing");
//4 用对象调用start 开启线程
t1.start();
MyThread2 t2 = new MyThread2("dance");
t2.start();
for (int i = 0; i < 100; i++) {
System.out.println("我打篮球" + i);
//Thread.currentThread() 获取当前线程对象 然后getName()获取线程的名字
//这里是主线程 名字是main
System.out.println(Thread.currentThread().getName());
}
}
}
实现多线程方式二：实现Runnable接口
Thread构造方法
| 方法名 | 说明 |
|---|---|
| Thread(Runnable target) | 分配一个新的Thread对象 |
| Thread(Runnable target, String name) | 分配一个新的Thread对象 |
实现步骤
- 定义一个类MyRunnable实现Runnable接口
- 在MyRunnable类中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable对象作为构造方法的参数传入
- 调用Thread类的对象的start方法启动线程
Runnable代码
- 类MyRunnable实现Runnable接口,重写run()方法,
- 方法中Thread.currentThread().getName()获取了线程的名字
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("吃肉夹馍" + i);
System.out.println(Thread.currentThread().getName());
}
}
}
线程测试代码
- 创建了三个线程
- 1 Thread t 在创建的时候，构造方法中传入了Runnable对象
- 2Thread t2，创建的时候使用lambda表达式传入了Runnable的实现类对象
- 3 直接在new Thread的时候使用lambda表达式传入了Runnable的实现类对象，然后直接start开启线程
//1创建了MyRunnable对象 里面存放了要执行的任务
MyRunnable r = new MyRunnable();
//2创建线程对象 把Runnable对象r传入线程里
//相当于把任务交给了线程
Thread t = new Thread(r);
//3 开启线程 会执行Runnable对象里的run方法
t.start();
Thread t2 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println("吃西瓜" + i);
System.out.println(Thread.currentThread().getName());
}
});
t2.start();
new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println("喝豆浆" + i);
System.out.println(Thread.currentThread().getName());
}
}).start();
两种实现方式的区别
- 第一种方式：需要自定义类，继承Thread类——子类不能再继承其它类了，比较受限制！
- 第二种方式：需要自定义类，实现Runnable接口——对于子类更灵活,更方便代码的面向对象设计。
多线程方式三: 实现Callable接口【应用】
-
方法介绍
方法名 说明 V call() 计算结果，如果无法计算结果，则抛出一个异常 FutureTask(Callable callable) 创建一个 FutureTask，一旦运行就执行给定的 Callable V get() 如有必要，等待计算完成，然后获取其结果 -
实现步骤
- 1定义一个类MyCallable实现Callable接口
- 2在MyCallable类中重写call()方法
- 3创建MyCallable类的对象
- 4创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 5创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 6启动线程
- 7FutureTask对象来调用get方法，就可以获取线程结束之后的结果。
代码 Callable部分
- 定义一个类MyCallable实现Callable接口
- 重写call()方法 方法的内容就是要执行的子线程的任务
- 方法的返回值 可以在子线程结束后 获取
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println("跟女孩表白" + i);
Thread.sleep(50);
}
//返回值就表示线程运行完毕之后的结果
return "答应";
}
}
代码 测试部分
- 创建MyCallable类的对象 mc
- 创建FutureTask类的对象，把mc作为构造方法的参数传入
- 创建线程对象
public static void main(String[] args) throws ExecutionException, InterruptedException {
//线程开启之后需要执行里面的call方法
MyCallable mc = new MyCallable();
//创建FutureTask对象ft 把mc传入，ft可以获取线程执行完毕之后的结果.
//FutureTask本身实现了Runnable接口
FutureTask<String> ft = new FutureTask<>(mc);
//创建线程对象 ft作为参数传递给Thread对象
Thread t1 = new Thread(ft);
//System.out.println("1111");
//String s = ft.get();//代码 阻塞
//System.out.println("222");
//开启线程
t1.start();
System.out.println("等待表白结果");
String s = ft.get();
System.out.println(s);
}
线程优先级
线程调度（了解）
-
两种调度方式
- 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
- 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
-
Java使用的是抢占式调度模型
-
随机性
假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的
相关方法
| 方法名 | 说明 |
|---|---|
| final int getPriority() | 返回此线程的优先级 |
| final void setPriority(int newPriority) | 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 |
代码
- 注意 优先级大，不一定先执行完，只是增加了抢占cpu的几率
class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "---" + i);
}
return "线程执行完毕了";
}
}
public class Demo02 {
public static void main(String[] args) {
//优先级: 1 - 10 默认值:5
MyCallable mc = new MyCallable();
FutureTask<String> ft = new FutureTask<>(mc);
Thread t1 = new Thread(ft);
t1.setName("飞机");
t1.setPriority(10);
//System.out.println(t1.getPriority());//获取优先级 默认值是5
t1.start();
MyCallable mc2 = new MyCallable();
FutureTask<String> ft2 = new FutureTask<>(mc2);
Thread t2 = new Thread(ft2);
t2.setName("坦克");
t2.setPriority(1);
//System.out.println(t2.getPriority());//获取优先级 默认值是5
t2.start();
}
}
守护线程
- 用户线程，jvm会等待用户线程全部结束，最后再结束程序.
- 守护线程, 当所有用户线程都结束后，由于jvm直接结束程序，守护线程会被直接结束掉
- 垃圾回收器 就是一个守护线程
- 应用：一般写 有一些监控功能的需求。 比如定时器
设置的方法
| 方法名 | 说明 |
|---|---|
| void setDaemon(boolean on) | 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出 |
代码
- 1代码有两个子线程t1和t2,唱歌和打球，主线程跳舞
- 2 设置t1和t2为守护线程，那么当用户线程执行完后，如果守护线程任务没有执行完，守护线程也会结束
public class Demo04 {
public static void main(String[] args) {
MThread1 t1 = new MThread1();
//设置为守护线程
t1.setDaemon(true);
t1.start();
MThread2 t2 = new MThread2();
t2.setDaemon(true);
t2.start();
for (int i = 0; i < 100; i++) {
System.out.println("跳舞" + i);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("跳完了");
}
}
class MThread1 extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 100; i++) {
System.out.println("唱歌" + i);
try {
sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("唱完了");
}
}
class MThread2 extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 100; i++) {
System.out.println("打篮球" + i);
try {
sleep(70);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("打完了");
}
}
线程同步
卖票案例
案例需求
- 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
实现步骤
- 1定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100; 表示票的数量
- 2 在SellTicket类中重写run()方法实现卖票，代码步骤如下
- 添加死循环，表示一直在买票
- 判断票数大于0，就卖票，并告知是哪个窗口卖的
- 卖了票之后，总票数要减1
- 票数小于等于0，线程停止
- 3 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
- 创建SellTicket类的对象
- 创建三个Thread类的对象，给线程定义名字为窗口1、窗口2、窗口3，把SellTicket对象作为构造方法的参数分别传给三个线程对象。
- 4启动3个线程
代码
- 注意：
- 代码中有三个线程对象，Runnable对象只有一个
public class SellTicket implements Runnable {
private int tickets = 100;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
while (true) {
if(ticket <= 0){
//判断ticket数量小于等于0，说明卖完了，结束循环
break;
}else{
try {
Thread.sleep(100);//模拟卖票消耗100ms
} catch (InterruptedException e) {
e.printStackTrace();
}
ticket--;//卖票 导致数量-1
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
}
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
//创建SellTicket类的对象
SellTicket st = new SellTicket();
//创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
Thread t1 = new Thread(st,"窗口1");
Thread t2 = new Thread(st,"窗口2");
Thread t3 = new Thread(st,"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();
}
}
卖票案例的问题【理解】
- 卖票出现了问题
- 相同的票出现了多次
- 出现了负数的票
- 问题产生原因
- 多个线程执行的随机性导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题
1同步代码块解决数据安全问题
- 安全问题出现的条件
- 是多线程环境
- 有共享数据，比如上面案例中的票的数量
- 有多条语句操作共享数据
- 如何解决多线程安全问题呢?
- 基本思想：让程序没有安全问题的环境
- 怎么实现呢?
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
- Java提供了同步代码块的方式来解决
- 同步代码块格式：
synchronized(任意对象) {
多条语句操作共享数据的代码
}
- synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
- 多个线程操作同一个代码块，要保证对象锁是同一个。
代码
- 注意 是操作共享数据的那块代码 放到同步代码块中
public class SellTicket implements Runnable {
private int tickets = 100;
private Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
//t1进来后，就会把这段代码给锁起来
if (tickets > 0) {
try {
Thread.sleep(100);
//t1休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//窗口1正在出售第100张票
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--; //tickets = 99;
}
}
//t1出来了，这段代码的锁就被释放了
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
同步的好处和弊端
- 好处：解决了多线程的数据安全问题
- 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
- 大家可以了解下 hashmap和hashtable的区别
代码的原子性
-
原子性 ：操作要么不间断地全部被执行，不受任何打扰，要么一个也没有执行
-
num++是非原子性操作，本质是3步完成
- 1获取num的值
- 2把num的值做+1计算
- 3 把计算后的值赋值给num
public class Demo02 {
public static void main(String[] args) {
A a = new A();
Thread t4 = new Thread(a);
Thread t5 = new Thread(a);
//Thread t6 = new Thread(a);
t4.start();
t5.start();
//t6.start();
}
}
class A implements Runnable {
private int num = 0;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
synchronized (this) {
num++;
}
}
System.out.println("num=" + num);
}
}
图解
同步方法 解决数据安全问题
同步方法的格式
- 同步方法：就是把synchronized关键字加到方法上
修饰符 synchronized 返回值类型 方法名(方法参数) {
方法体；
}
同步方法的锁对象是什么呢? 是 this
静态同步方法（了解）
- 同步静态方法：就是把synchronized关键字加到静态方法上
修饰符 static synchronized 返回值类型 方法名(方法参数) {
方法体；
}
-
同步静态方法的锁对象是什么呢? 是类名.class
代码
public class MyRunnable implements Runnable {
private int ticketCount = 100;
@Override
public void run() {
while(true){
if("窗口一".equals(Thread.currentThread().getName())){
//同步方法
boolean result = synchronizedMthod();
if(result){
break;
}
}
if("窗口二".equals(Thread.currentThread().getName())){
//同步代码块
synchronized (this){
if(ticketCount == 0){
break;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
}
}
}
}
}
private synchronized boolean synchronizedMthod() {
if(ticketCount == 0){
return true;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
return false;
}
}
}
测试代码
- 这里两个线程，都行mr对象的里的任务
- 一个使用同步代码块，一个使用同步方法
- 这里同步代码块和同步方法的锁都是this，也就是当前的runnable对象mr
public class Demo {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.setName("窗口一");
t2.setName("窗口二");
t1.start();
t2.start();
}
}
Lock锁
-
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
-
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
-
ReentrantLock构造方法
方法名 说明 ReentrantLock() 创建一个ReentrantLock的实例 -
加锁解锁方法
方法名 说明 void lock() 获得锁 void unlock() 释放锁
代码
- lock.lock()加锁
- 释放锁lock.unlock(); 一般写在finally中保证正常执行
public class Ticket implements Runnable {
//票的数量
private int ticket = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
==
try {
lock.lock();//加锁
if (ticket <= 0) {
//卖完了
break;
} else {
Thread.sleep(100);
ticket--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();//释放锁
}
}
}
}
public class Demo {
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
死锁
- 在一个锁里嵌套添加另外一个锁
- 当多线程时，导致都卡到两个锁的中间，程序停滞处于等待状态
public static void main(String[] args) {
Object objA = new Object();
Object objB = new Object();
new Thread(()->{
while(true){
synchronized (objA){
//线程一
System.out.println("小康进入a");
synchronized (objB){
System.out.println("小康进入b");
System.out.println("小康同学正在走路");
}
}
}
}).start();
new Thread(()->{
while(true){
synchronized (objB){
//线程二
System.out.println("小薇进入B");
synchronized (objA){
System.out.println("小薇进入A");
System.out.println("小薇同学正在走路");
}
}
}
}).start();
}
浙公网安备 33010602011771号