Java多线程(二)

Java多线程(二)

Java多线程(二)

目录
  • Java多线程(二)
      • 四、线程的同步
        • 4.1 线程同步的引入:
        • 4.2 线程同步的方式之一:同步代码块
        • 4.3 线程同步的方式之二:同步方法
        • 4.4 同步的优势与局限:
        • 4.5 线程安全的单例模式之懒汉式
        • 4.6 同步锁机制:
        • 4.7 释放锁的操作:
        • 4.8 不会释放锁的操作:
        • 4.9 线程的死锁问题
        • 4.10 线程同步的方式之三:Lock锁
        • 4.11 (简单介绍)公平锁和非公平锁

四、线程的同步

4.1 线程同步的引入:

  • 多线程出现了安全问题
  • 问题的原因: 当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。例如:买票问题、银行卡消费问题等等。
  • 解决办法: 对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行

​ 所以,Java 对于多线程的安全问题提供了专业的解决方式:同步机制

4.2 线程同步的方式之一:同步代码块

  1. 语法格式:
synchronized (对象/同步监视器){	//得到对象的锁,才能操作同步代码
	// 需要被同步的代码
}

说明:

​ (1)操作共享数据的代码,即为需要被同步的代码。 --> 不能包含代码多了,也不能包含代码少了。

​ (2)共享数据:多个线程共同操作的变量。

​ (3)同步监视器,俗称:锁。任何一个类的对象,都可以充当锁

​ (4)要求:多个线程必须要共用同一把锁

  1. 使用同步代码块解决在实现 Runnable 接口的方式创建多线程的线程安全问题
//	例子:创建三个窗口卖票,总票数为100张.使用实现Runnable接口的方式
class Window1 implements Runnable{

    private int ticket = 100;
//    Object obj = new Object();
    @Override
    public void run() {
//      Object obj = new Object();
        while(true){
            // 同步代码块---begin
            synchronized (this){	// 此时的this:唯一的 Window1 的对象w   //方式二:synchronized (object) {

                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
            // 同步代码块---end
        }
    }
}

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("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  1. 使用同步代码块解决继承 Thread 类的方式创建多线程的线程安全问题
class Window2 extends Thread{

    private static int ticket = 100;
//    private static Object obj = new Object();

    @Override
    public void run() {

        while(true){

            synchronized (Window2.class){//	Window2.class表示window2这一个类,只会加载一次
//       方式二:synchronized (obj){	               
//              synchronized (this){	错误的方式:this分别代表着t1,t2,t3三个对象

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(getName() + ":卖票,票号为:" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

4.3 线程同步的方式之二:同步方法

  1. 同步方法:即将操作共享数据的代码完整的声明在一个方法中,将该方法声明为同步方法。

  2. 语法格式:

//	将synchronized放在方法声明中,一般放在权限符和返回类型之间,表示整个方法为同步方法
public synchronized void 方法名 (String name){ 
	// 需要被同步的代码
}

说明:

(1)同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。

(2)非静态的同步方法,同步监视器是:this。

(3)静态的同步方法,同步监视器是:当前类本身。

  1. 使用同步方法解决在实现 Runnable 接口的方式创建多线程的线程安全问题
class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    private synchronized void show(){	//同步监视器: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("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  1. 使用同步方法解决继承 Thread 类的方式创建多线程的线程安全问题
class Window4 extends Thread {

    private static int ticket = 100;

    @Override
    public void run() {

        while (true) {
            show();
        }
    }
    
    private static synchronized void show(){	//同步监视器:Window4.class
        //private synchronized void show(){ //同步监视器:t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
            ticket--;
        }
    }
}


public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

总结:

通过上面四个售票例子可以看出:

在实现 Runnable 接口创建多线程的方式中,我们可以考虑使用 this 充当同步监视器。

而在继承Thread类创建多线程的方式一般不使用 this 充当同步监视器,因为每个线程的 this 为该线程的实例对象,不满足多个线程共用一把锁,所以一般考虑用当前类本身充当。

4.4 同步的优势与局限:

  • 优势:解决了线程的安全问题。

  • 局限: 操作同步代码时,只能有一个线程参与,其他线程等待。相当于是一个单线程的过程,效率低。也可能会造成死锁问题。

4.5 线程安全的单例模式之懒汉式

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;
    }
}

/*
	方式二效率更高的原因:
	不需要每个线程都要进去同步方法里面去,可能只有最前面几个进程进入同步方法。
	而方式一是所有线程都要进入同步方法导致效率较低。
*/

4.6 同步锁机制:

  • 同步机制中的锁在《Thinking in Java》中,是这么说的:对于并发工作,你需要某种方式来防止两个任务访问相同的资源(其实就是共享资源竞争)。防止这种冲突的方法就是当资源被一个任务使用时,在其上加锁。第一个访问某项资源的任务必须锁定这项资源,使其他任务在其被解锁之前,就无法访问它了,而在其被解锁之时,另一个任务就可以锁定并使用它了。

  • synchronized的锁是什么?

    1. 任意对象都可以作为同步锁。所有对象都自动含有单一的锁(监视器)。

    2. 同步方法的锁:静态方法(类名.class)、非静态方法(this)。

    3. 同步代码块:可以自己指定,很多时候也是指定为this或类名.class。

  • 注意:

    1. 必须确保使用同一个资源的多个线程共用一把锁,否则就无法保证共享资源的安全 。
    2. 一个线程类中的所有静态方法共用同一把锁(类名.class),所有非静态方法共用同一把锁(this),同步代码块(指定需谨慎)。

4.7 释放锁的操作:

  1. 当前线程的同步方法、同步代码块执行结束。
  2. 当前线程在同步代码块、同步方法中遇到 break、return 终止了该代码块、该方法的继续执行。
  3. 当前线程在同步代码块、同步方法中出现了未处理的 Error 或 Exception,导致异常结束。
  4. 当前线程在同步代码块、同步方法中执行了线程对象的 wait() 方法,当前线程暂停,并释放锁。

4.8 不会释放锁的操作:

  1. 线程执行同步代码块或同步方法时,程序调用 Thread.sleep()、 Thread.yield() 方法暂停当前线程的执行。

  2. 线程执行同步代码块时,其他线程调用了该线程的 suspend() 方法将该线程挂起,该线程不会释放锁(同步监视器)。

    应尽量避免使用suspend()和resume()来控制线程

4.9 线程的死锁问题

  1. 死锁:

    • 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁。
    • 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续。
  2. 解决方法:

    • 专门的算法、原则。
    • 尽量减少同步资源的定义。
    • 尽量避免嵌套同步。
  3. 例子:

//死锁的演示
class A {
	public synchronized void foo(B b) { //同步监视器:A类的对象:a
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法"); // ①
//		try {
//			Thread.sleep(200);
//		} catch (InterruptedException ex) {
//			ex.printStackTrace();
//		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法"); // ③
		b.last();
	}

	public synchronized void last() {//同步监视器:A类的对象:a
		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {//同步监视器:b
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法"); // ②
//		try {
//			Thread.sleep(200);
//		} catch (InterruptedException ex) {
//			ex.printStackTrace();
//		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法"); // ④
		a.last();
	}

	public synchronized void last() {//同步监视器:b
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}

	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		new Thread(dl).start();

		dl.init();
	}
}
  1. 注意:

    不是程序运行成功就说明程序里面没有死锁问题,很多时候出现死锁是一个概率问题。在开发中应尽量避免死锁情况。

4.10 线程同步的方式之三:Lock锁

  1. JDK 5.0 开始,Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用 Lock 对象充当。

  2. java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对 Lock 对象加锁,线程开始访问共享资源之前应先获得 Lock 对象。

  3. ReentrantLock 类实现了 Lock ,它拥有与 synchronized 相同的并发性和 内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以 显式加锁、释放锁。

  4. 语法:

class A{
    //1.实例化ReentrantLock
	private final ReentrantLock lock = new ReenTrantLock();
    
	public void m(){
        //2.调用锁定方法lock()
		lock.lock();
		try{
			//保证线程安全的代码;
		}
		finally{
            //3.调用解锁方法:unlock()
			lock.unlock(); 
		}
	}
}

  1. (面试题)synchronized 与 Lock 的对比

    • 相同:二者都可以解决线程安全问题。
    • 不同:
      1. Lock 是显式锁(手动开启和关闭锁),synchronized 是隐式锁,出了作用域自动释放。
      2. Lock 只有代码块锁,synchronized 有代码块锁和方法锁。
      3. 使用 Lock 锁,JVM 将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)。
  2. 优先使用顺序:

Lock —— 同步代码块(已经进入了方法体,分配了相应资源) —— 同步方法(在方法体之外)

4.11 (简单介绍)公平锁和非公平锁

  1. 公平锁(Fair):加锁前检查是否有排队等待的线程,优先排队等待的线程,先来先得。

    非公平锁(Nonfair):加锁时不考虑排队等待问题,直接尝试获取锁,获取不到自动到队尾等待。

  2. Java中的 ReentrantLock 默认的 lock() 方法采用的是非公平锁。

//	源码:
//	ReentrantLock当中的lock()方法,是通过static内部类sync来进行锁操作
public void lock() 
{
     sync.lock();
}
-------------------------------------------------------------------
//定义成final型的成员变量,在构造方法中进行初始化 
private final Sync sync;
//无参数默认非公平锁
public ReentrantLock() 
{
    sync = new NonfairSync();
}
//根据参数初始化为公平锁或者非公平锁 
public ReentrantLock(boolean fair) 
{
    sync = fair ? new FairSync() : new NonfairSync();
}

原文地址:https://www.cnblogs.com/xiaozhao01/archive/2022/08/05/16555150.html