Java开发:同步锁同步效果详解

1个同步锁1.1个前言

经过前面多线程编程的学习,我们遇到了线程安全相关的问题,比如多线程票务场景超卖/重卖等问题。

上一节在这里注释——进程和线程注释

我们如何判断程序是否可能存在线程安全问题,主要有以下三种情况:

在多线程程序中+有共享数据+多条语句操作共享数据

共享数据的多线程场景和条件不能改变(比如4个窗口一起卖100张票,这就是生意)

所以思路可以从第三点“多条语句操作共享数据”开始,因为这些多条语句在操作数据的过程中存在问题

那我们可以把可能有问题的代码包装起来,一次只允许一个线程执行

1.2 同步和异步

怎么会有问题?我们可以使用synchronized关键字来实现同步效果

也就是说,当多个对象对共享数据进行操作时,我们可以使用同步锁来解决线程安全问题,并且被锁代码是同步的

接下来,我将介绍同步和异步的概念:

同步:体现排队的效果。只有一个线程可以同时独占资源,其他线程无权。线程已排队。

缺点是效率会降低,但安全有保障。

异步:体现多线程抢占资源的效果。线程不会互相等待,也不会互相抢占资源。

缺点是存在安全隐患,效率较高。

1.3种同步同步关键字1.3.1种写法

同步(锁定对象){

必需的同步代码(即对可能有问题的共享数据进行操作的多个语句);

}

1.3.2个前提

使用同步效果有两个前提:

1.3.3 特点 synchronized 关键字可以用来修改方法,称为同步方法,它使用锁对象 可以用来修改代码块的就是thissynchronized同步关键字,称为synchronized代码块。使用可以任意同步的锁对象的缺点是会降低程序的执行效率,但是为了保证线程安全,必须牺牲一些性能,但是为了性能,需要控制好锁的范围。比如我们不需要锁整个商场,锁试衣间就可以了。

为什么同步代码块的锁对象可以是任意同一个对象,而同步方法用的是这个?

因为同步代码块可以保证同时只有一个线程进入

但是同步方法不能保证同一时间只能有一个线程调用,所以使用这个类来引用对象this来保证同步

1.4.1运动改造售票案例

创建包:cn.tedu.tickets

创建类:TestRunnableV2.java

package cn.tedu.tickets;
/*需求:改造售票案例,解决多线程数据不安全的问题*/
public class TestRunnableV2 {
    public static void main(String[] args) {
        //5.创建目标业务对象
        TicketRunnable target = new TicketRunnable();
        //6.使用Thread类中的含参构造,将目标对象与线程对象做绑定
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        //7.以多线程的方式启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
/*1.多线程中出现数据安全隐患的原因:
*多线程程序 + 有共享数据(成员变量) + 多条语句操作共享数据 */
/*2.同步锁:相当于给容易出现问题的代码加了一把锁,包裹了所有可能会出现安全隐患的代码
加锁之后,就有同步(排队)的效果,但是加锁的范围,需要考虑:
不能太大,太大,干啥都得排队,效率低,范围太小,太小,锁不住,还是会有安全隐患*/
//1.创建自定义多线程类
class TicketRunnable implements Runnable{
    //3.创建成员变量,用来保存票数,注意必须是静态的
    static int tickets = 100;
    //8.2创建一个唯一的锁对象
    /*5.不论之后是哪个线程进同步代码块,使用的都是唯一的锁对象,"唯一"很重要*/
    Object o = new Object();
    //2.添加接口中未实现的方法,把业务放在run()里
    @Override
    /*6.如果一个方法中的所有代码都需要同步,那这个方法可以设置成同步方法*/
    //synchronized public void run() {/*被sychronized关键字修饰的方法是同步方法*/
    public void run() {/*被sychronized关键字修饰的方法是同步方法*/
        while (true){
            //8.1使用同步代码块包裹可能会出现安全隐患的代码,锁对象类型任意
            /*3.同步代码块:sychronized(锁对象){会出现安全问题的代码}
             * 同步代码块中,同一时刻,同一资源,只能被一个线程独享*/
            /*4.这种写法不对,相当于每个线程进来都会new一个锁对象,线程间并不是使用同一把锁*/
            //synchronized (new Object()) {
            //8.3修改同步代码块的锁对象为成员变量o,注意,"唯一"很重要
            synchronized (o) {
                //3.获取当前正在卖票的线程名称,以及卖票
                if(tickets > 0){//还有票的情况下就卖票
                    try {
                        //让程序休眠后出现的两个问题:
                        //问题1.重卖:一张票卖给了多个人
                        //问题2.超卖:出现了票数为0甚至是负数的情况
                        Thread.sleep(10);//让程序休眠10ms
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                //4.设置死循环的出口
                if (tickets <= 0) break;
            }
        }
    }
}

1.4.2练习-装修票务案例

创建包:cn.tedu.tickets

创建类:TestThreadV2.java

p>

package cn.tedu.tickets;
/*需求:设计多线程编程模型,4个窗口共计售票100张*/
/*本类通过继承Thread类的方式实现多线程售票案例*/
public class TestThreadV2 {
    public static void main(String[] args) {
        //5.创建多个线程对象 Ctrl+D 复制当前行
        TicketThread t1 = new TicketThread();
        TicketThread t2 = new TicketThread();
        TicketThread t3 = new TicketThread();
        TicketThread t4 = new TicketThread();
        //6.以多线程的方式启动
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
//1.自定义线程售票业务类
class TicketThread extends Thread {
    //3.定义变量,用来保存票数
    //int tickets = 100;//不可以,会卖400张票
    //7.解决4个线程卖了400张票的BUG
    static int tickets = 100;//静态资源属于类资源,被全局所有对象共享,只有一份
    //2.把业务写在重写run()里
    @Override
    public void run() {
        //4.通过循环结构来一直卖票
        while (true) {
            synchronized (TicketThread.class) {
                if (tickets > 0) {
                    try {
                        //8.如果数据能够经受住sleep的考验,才能说明数据没有了安全隐患--人为制造问题
                        //问题1:产生了重卖:同一张票卖给了多个人
                        //问题2:产生了超卖:超出了规定票数,甚至卖出了0和-1这样的票数
                        Thread.sleep(10);//让程序休眠10ms
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + "=" + tickets--);
                }
                //做判断,如果没有票了,就退出死循环
                if (tickets <= 0) break;//注意,死循环一定要设置出口
            }
        }
    }
}

注意:如果是继承方式,锁对象最好使用“类名.class”,否则在创建自定义线程类的多个对象时,无法保证锁的唯一性

图片[1]-Java开发:同步锁同步效果详解-老王博客

1.之前遇到的5个同步例子

StringBuffer JDK1.0

添加同步,性能相对较低(队列,同步),安全性高

StringBuilder JDK1.5

去掉同步,性能更高(无队列,异步),存在安全隐患

快速查找快捷键:Ctrl+Shift+T

2 其他线程创建方式2.1 ExecutorService/Executors

ExecutorService:一个用于存储线程的池,放置新线程/启动/关闭线程的任务交给池进行管理

执行器是帮助创建线程池的工具

2.2 练习:创建线程的其他方法

p>

创建包:cn.tedu.tickets

创建类:TestRunnableV2.java

public class TestRunnableV2 {
	public static void main(String[] args) {
		//5.创建接口实现类对象作为目标对象(目标对象就是要做的业务)
		SaleTicketsV2 target = new SaleTicketsV2();
		//6.将目标对象与Thread线程对象绑定
//		Thread t1 = new Thread(target);
//		Thread t2 = new Thread(target);
//		Thread t3 = new Thread(target);
//		Thread t4 = new Thread(target);
		//7.以多线程的方式启动线程--会将线程由新建状态变为就绪状态
		/**1.如果只创建了一个线程对象,是单线程场景,不会出现数据问题*/
//		t1.start();
//		t2.start();
//		t3.start();
//		t4.start();
		/**7.线程池ExecutorService:用来存储线程的池子,把新建线程/启动线程/关闭线程的任务都交给池来管理*/
		/**8.Executors用来辅助创建线程池对象,newFixedThreadPool()创建具有参数个数的线程数的线程池*/
		ExecutorService pool = Executors.newFixedThreadPool(5);
		for(int i = 0;i<5;i++) {
			/**9.excute()让线程池中的线程来执行任务,每次调用都会启动一个线程*/
			pool.execute(target);//本方法的参数就是执行的业务,也就是实现类的目标对象
		}
	}

3 扩展:线程锁3.1 悲观锁和乐观锁

悲观锁:就像它的名字一样,它对并发操作引起的线程安全问题持悲观态度。

悲观锁认为竞争总是会发生的,所以每次操作一个资源时,都会持有一个排他锁,就像同步一样,不管是否被锁,直接操作资源。

乐观锁:还是跟它的名字一样,看好并发操作带来的线程安全问题。

乐观锁认为竞争不会一直发生,所以并不一定要持有锁,将“比较-替换”这两个动作作为一个原子操作来尝试修改内存中的变量。如果失败,说明冲突,应该有相应的重试逻辑。

3.2 两个普通锁

同步互斥锁(悲观锁,有罪假设)

使用synchronized修饰符进行同步 该机制称为互斥锁机制,它获取的锁称为互斥锁。

每个对象都有一个监视器(lock tag),一个线程只有拥有lock tag才能访问资源。如果没有锁标签同步代码块的锁是什么,它将进入锁池。任何对象系统都会为它创建一个互斥锁。这个锁被分配给线程以防止中断原子操作。每个对象的锁只能分配给一个线程,所以称为互斥锁。

ReentrantLock 排他锁(悲观锁,有罪假设)

ReentrantLock是排他锁,只有一个线程可以同时访问排他锁,其实排他锁是一种相对比较保守的锁定策略,其中任何“读/读”、“读/写” ", "write/write" 操作不能同时发生,这在一定程度上降低了吞吐量。但是,读取操作之间不存在数据竞争问题。如果“读/读”操作可以以共享锁的方式进行,性能将进一步提升。

ReentrantReadWriteLock 读写锁(乐观锁,无罪假设)

因此,引入了 ReentrantReadWriteLock。顾名思义,ReentrantReadWriteLock就是可重入(reentrant)读(read)写(write)锁(lock),下面我们称之为读写锁。

读写锁分为读锁和写锁。在没有写锁的情况下,读锁可以被多个线程同时持有,并且写锁是独占的。

读锁和写锁分离,提高程序性能。读写锁主要用于多读少写的场景。

3.3 尝试使用读写锁改造票务案

package cn.tedu.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
 * 本类用于改造售票案例,使用可重入读写锁
 * ReentrantReadWriteLock
 * */
public class TestSaleTicketsV3 {
	public static void main(String[] args) {
		SaleTicketsV3 target = new SaleTicketsV3();
		Thread t1 = new Thread(target);
		Thread t2 = new Thread(target);
		Thread t3 = new Thread(target);
		Thread t4 = new Thread(target);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
class SaleTicketsV3 implements Runnable{
	static int tickets = 100;
	//1.定义可重入读写锁对象,静态保证全局唯一
	static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
	@Override
	public void run() {
		while(true) {
			//2.在操作共享资源前上锁
			lock.writeLock().lock();
			try {
				if(tickets > 0) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "=" + tickets--);
				}
				if(tickets <= 0) break;
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				//3.finally{}中释放锁,注意一定要手动释放,防止死锁,否则就独占报错了
				lock.writeLock().unlock();
			}
		}
	}
} 

3.4 两种方式的区别

需要注意的是,在用synchronized修改的方法或语句块中的代码执行后,锁会自动释放,但是锁需要我们手动释放锁,所以为了保证锁是finally释放(发生异常),将互斥锁放入try,最后释放锁!

与互斥锁相比,读写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程(写入器线程)可以修改共享数据,但在许多情况下,任意数量的线程都可以同时读取共享数据(读取器线程)。锁允许的并发性增加将带来更大的性能提升。

恭喜,线程和线程锁的学习可以暂时告一段落,接下来我们可以继续学习其他内容

下一部分,设计模式同步代码块的锁是什么,点击这里

© 版权声明
THE END
喜欢就支持一下吧
点赞0
分享
评论 抢沙发

请登录后发表评论