Java多线程（二）
文章目录
- 一、线程的生命周期
-
- 1.如图所示
- 二、解决线程安全问题 方式一：同步代码块
-
- 1.格式
- 2.说明
- 3.同步代码块的方式解决实现Runnable接口的线程安全问题
- 4.使用同步代码块处理继承Thread类的方式中的线程安全问题
- 三、解决线程安全问题 方式二：同步方法
-
- 1.使用同步方法解决实现Runnable接口的线程安全问题
-
- 1.总结
- 2.代码
- 2.使用同步方法处理继承Thread类的方式中的线程安全问题
- 四、同步机制的好坏处
- 五、解决线程安全问题的方式三：Lcok --JDK5.0新增
-
- 1.synchronized 与 Lock的导同?
- 2.优先使用顺序
- 3.代码案例
- 六、使用同步机制将单例模式中的懒汉式改写为线程安全的
提示：以下是本篇文章正文内容，下面案例可供参考
一、线程的生命周期
1.如图所示
二、解决线程安全问题 方式一：同步代码块
1.格式
synchronized(同步监视器){
//需要被同步的代码
}
2.说明
1…操作共享数据的代码，即为需要被同步的代码.不能包含代码多了，也不能包含代码少了
2.共享效据:多个线程共同操作的变量。比如: ticket 就是共享数据
3.同步监视器，俗称:锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一把锁。
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this 充当同步监视器。
3.同步代码块的方式解决实现Runnable接口的线程安全问题
package com.tyust.java1;
/**
* @author YML TYUST-XDU 2019-2026
* @create 2023-09-22 9:19
* 同步代码块的方式解决实现Runnable接口的线程安全问题
*/
class Window1 implements Runnable{
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true){
//此时的this：唯一的windows1对象
synchronized(this){//synchronized (obj){
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 卖票，票号为：" + ticket);
ticket--;
}else{
break;
}
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
4.使用同步代码块处理继承Thread类的方式中的线程安全问题
package com.tyust.java1;
/**
* @author YML TYUST-XDU 2019-2026
* @create 2023-09-22 8:57
* 使用同步代码块处理继承Thread类的方式中的线程安全问题
*/
class Window2 extends Thread{
private static int ticket = 100;
private static Object obj = new Object();
@Override
public void run() {
while(true){
//错误的方式: this代表者t1,t2,t3三个对象
//synchronized (this){
synchronized (obj){
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ": 卖票，票号为：" + ticket);
ticket--;
}else{
break;
}
}
}
}
}
public class WindowTest2 {
public static void main(String[] args) {
Window2 w1 = new Window2();
Window2 w2 = new Window2();
Window2 w3 = new Window2();
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");
w1.start();
w2.start();
w3.start();
}
}
三、解决线程安全问题 方式二：同步方法
1.使用同步方法解决实现Runnable接口的线程安全问题
1.总结
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
2.非静态的同步方法，同步监视器是: this
静态的同步方法，同步监视器是:当前类本身
2.代码
package com.tyust.java2;
/**
* @author YML TYUST-XDU 2019-2026
* @create 2023-09-22 9:19
* 使用同步方法解决实现Runnable接口的线程安全问题
*/
class Window3 implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true){
show();
}
}
private synchronized void show(){
//synchronized (this){
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 卖票，票号为：" + ticket);
ticket--;
}
//}
}
}
public class WindowTest3 {
public static void main(String[] args) {
Window3 w = new Window3();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
2.使用同步方法处理继承Thread类的方式中的线程安全问题
package com.tyust.java2;
/**
* @author YML TYUST-XDU 2019-2026
* @create 2023-09-22 8:57
* 使用同步方法处理继承Thread类的方式中的线程安全问题
*/
class Window4 extends Thread{
private static int ticket = 100;
@Override
public void run() {
while(true){
show();
}
}
//private synchronized void show(){ //同步监视器：t1 t2 t3 不是唯一的
private static synchronized void show(){ //同步监视器是唯一的 Window4.class 是唯一的
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ": 卖票，票号为：" + ticket);
ticket--;
}
}
}
public class WindowTest4 {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");
w1.start();
w2.start();
w3.start();
}
}
四、同步机制的好坏处
同步的方式，解决了线程的安全问题。— 好处
操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低 ------局限性
五、解决线程安全问题的方式三：Lcok --JDK5.0新增
1.synchronized 与 Lock的导同?
相同:二者都可以解决线程安全问题
不同: synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器Lock需要手动的启动同步 (Lock())，同时结束同步也要手动的实现 (unlock())
2.优先使用顺序
Lock > 同步代码块 (已经进入了方法体，分配了相应资源) ->同步方法(在方法体之外
3.代码案例
package com.tyust.java3;
import java.util.concurrent.locks.ReentrantLock;
/**
* 解决线程安全问题的方式三：Lock -- JDK5.0新增
* @author YML TYUST-XDU 2019-2026
* @create 2023-09-22 18:01
*/
class Window implements Runnable{
private int ticket = 100;
//实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while(true){
try{
//2.调用锁定方法lock()
lock.lock();
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName()
+": 售票，票号为：" + ticket);
ticket --;
}else {
break;
}
}finally{
//3.调用解锁方法unlock()
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
六、使用同步机制将单例模式中的懒汉式改写为线程安全的
package com.tyust.java3;
/**
* @author YML TYUST-XDU 2019-2026
* @create 2023-09-22 17:28
* 使用同步机制将单例模式中的懒汉式改写为线程安全的
*/
public class BankTest {
}
class Bank {
private Bank() {
}
private static Bank instance = null;
public static Bank getInstance() {
//方式一：效率稍差
// synchronized (Bank.class){
// if(instance == null){
// instance = new Bank();
// }
// return instance;
// }
// //方式二：效率更高
if (instance == null) {
synchronized (Bank.class) {
if (instance == null) {
instance = new Bank();
}
}
}
return instance;
}
}