这里是JAVA多线程加油站
如果对你有帮助，给博主一个免费的点赞以示鼓励
欢迎各位点赞评论收藏??
话不多说上案例
文章目录
-
- 问题一：A线程正在执行一个对象中的同步方法，B线程是否可以同时执行同一个对象中的非同步方法？
- 问题二：同上，B线程是否可以同时执行同一个对象中的另一个同步方法？
- 问题三：线程抛出异常会释放锁吗？
- 问题四：写一个程序，证明AtomicInteger类比synchronized更高效
- 问题五：写一个程序证明AtomXXX类的多个方法并不构成原子性
- 问题六：写一个程序，在main线程中启动100个线程，100个线程完成后，主线程打印“完成”
问题一：A线程正在执行一个对象中的同步方法，B线程是否可以同时执行同一个对象中的非同步方法？ 可以，两个线程运行所需资源不同，不需要抢占。
案例一、
package duoxiancheng2;
/**
* @author yeqv
* @program A2
* @Classname Ms1
* @Date 2022/2/7 19:08
* @Email w16638771062@163.com
*/
public class Ms1 {
//A线程正在执行一个对象中的同步方法，B线程是否可以同时执行同一个对象中的非同步方法？
Object a = new Object();
public static void main(String[] args) {
var t = new Ms1();
new Thread(() -> t.a1()).start();
//A线程
new Thread(() -> t.a2()).start();
//B线程
}void a1() {
synchronized (a) {
System.out.println("同步方法");
}
}void a2() {
System.out.println("非同步方法");
}
}运行结果：
文章图片
问题二：同上，B线程是否可以同时执行同一个对象中的另一个同步方法？ 不可以，两个线程执行需要一个共同资源，共同资源加了同步锁，同一时刻只能一个线程占用。
案例二、
package duoxiancheng2;
import java.util.concurrent.TimeUnit;
/**
* @author yeqv
* @program A2
* @Classname Ms2
* @Date 2022/2/7 19:25
* @Email w16638771062@163.com
*/
public class Ms2 {
//同上，B线程是否可以同时执行同一个对象中的另一个同步方法？
Object a = new Object();
public static void main(String[] args) {
var t = new Ms2();
new Thread(() -> t.a1()).start();
//A线程
new Thread(() -> t.a2()).start();
//B线程
}
void a1() {
synchronized (a) {
System.out.println("进入同步方法1");
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("同步方法1结束");
}
}
void a2() {
synchronized (a) {
System.out.println("进入同步方法2");
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("同步方法2结束");
}
}
}运行结果：
线程A先运行，占用资源。
文章图片
等线程A运行完释放资源后，线程B才可以进入执行
文章图片
线程B执行完
文章图片
问题三：线程抛出异常会释放锁吗？ 会，线程出现异常抛出后立刻释放资源。
案例三、
package duoxiancheng2;
import java.util.concurrent.TimeUnit;
/**
* @author yeqv
* @program A2
* @Classname Ms3
* @Date 2022/2/7 19:41
* @Email w16638771062@163.com
*/
public class Ms3 {
//线程抛出异常会释放锁吗？
Object a = new Object();
public static void main(String[] args) {
var t = new Ms3();
new Thread(() -> t.a1()).start();
//A线程
new Thread(() -> t.a2()).start();
//B线程
}void a1() {
int c = 3;
int b;
synchronized (a) {
System.out.println("进入同步方法1");
try {
b = c / 0;
System.out.println(b);
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("同步方法1结束");
}
}void a2() {
synchronized (a) {
System.out.println("进入同步方法2");
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("同步方法2结束");
}
}
}结果：
方法一出现异常，立刻释放资源。线程二开始执行
文章图片
问题四：写一个程序，证明AtomicInteger类比synchronized更高效 synchronized更高效
案例一
package duoxiancheng2;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author yeqv
* @program A2
* @Classname Ms4
* @Date 2022/2/7 20:04
* @Email w16638771062@163.com
*/
public class Ms4 {AtomicInteger n = new AtomicInteger(10000);
int num = 10000;
public static void main(String[] args) {var t = new Ms4();
new Thread(t::minus, "T1").start();
new Thread(t::minus, "T2").start();
new Thread(t::minus, "T3").start();
new Thread(t::minus, "T4").start();
new Thread(t::minus, "T5").start();
new Thread(t::minus, "T6").start();
new Thread(t::minus, "T7").start();
new Thread(t::minus, "T8").start();
}void minus() {
var a = System.currentTimeMillis();
while (true) {
/* if (n.get() > 0) {
n.decrementAndGet();
System.out.printf("%s 售出一张票，剩余%d张票。 %n", Thread.currentThread().getName(), n.get());
} else {
break;
}*/
synchronized (this) {
if (num > 0) {
num--;
System.out.printf("%s 售出一张票，剩余%d张票。 %n", Thread.currentThread().getName(), num);
} else {
break;
}}}
var b = System.currentTimeMillis();
System.out.println(b - a);
}
}
synchronized结果：
文章图片
AtomicInteger结果：
文章图片
问题五：写一个程序证明AtomXXX类的多个方法并不构成原子性
package demo16;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 写一个程序证明AtomXXX类的多个方法并不构成原子性
*/
public class T {
AtomicInteger count = new AtomicInteger(0);
void m() {
for (int i = 0;
i < 10000;
i++) {
if (count.get() < 100 && count.get() >= 0) { //如果未加锁,之间还会有其他线程插进来
count.incrementAndGet();
}
}
}public static void main(String[] args) {
T t = new T();
List threads = new ArrayList<>();
for (int i = 0;
i < 10;
i++) {
threads.add(new Thread(t::m, "thread" + i));
}
threads.forEach(Thread::start);
threads.forEach((o) -> {
try {
//join()方法阻塞调用此方法的线程,直到线程t完成，此线程再继续。通常用于在main()主线程内，等待其它线程完成再结束main()主线程。
o.join();
//相当于在main线程中同步o线程，o执行完了，main线程才有执行的机会
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println(t.count);
}
}
【JAVA高并发程序设计|六道热门多线程面试题，你学废了吗?】**
问题六：写一个程序，在main线程中启动100个线程，100个线程完成后，主线程打印“完成”
package cn.thread;
import java.util.concurrent.CountDownLatch;
/**
* 写一个程序，在main线程中启动100个线程，100个线程完成后，主线程打印“完成”
*
* @author webrx [webrx@126.com]
* @version 1.0
* @since 16
*/
public class T12 {
public static void main(String[] args) {
CountDownLatch latch = new CountDownLatch(100);
for (int i = 0;
i < 100;
i++) {
new Thread(() -> {
String tn = Thread.currentThread().getName();
System.out.printf("%s : 开始执行...%n", tn);
System.out.printf("%s : 执行完成，程序结束。%n", tn);
latch.countDown();
}, "T" + i).start();
}try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---------------------------------------");
System.out.println("100个线程执行完了。");
String tn = Thread.currentThread().getName();
System.out.printf("%s : 执行完成，程序结束。%n", tn);
}
}
推荐阅读
- JAVA高并发程序设计|带你深度刨析多线程的同步控制
- SQL数据库|MySQL数据库（基础）
- Java基础总结|Java期末复习速成（五）
- Java|Java基础语法练习题
- Java|Java面向对象题库
- vue|Vue入门项目（学生管理系统之班级管理 【含源码】）
- mybatis|Mybatis-plus通用CRUD
- spring|谈谈你对SSM简答题的理解 && SpringMVC执行流程
- 计算机毕业设计|Java项目（基于springboot+vue的学生宿舍管理系统—计算机毕业设计）