简单的使用synchronized关键字和Lock接口的练习

最新推荐文章于 2022-11-14 19:10:59 发布
最新推荐文章于 2022-11-14 19:10:59 发布
阅读量215 收藏
点赞数
分类专栏： javaSe 文章标签： java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dzz_bc/article/details/80203293
版权

synchronized

package lock的使用;

import java.text.SimpleDateFormat;
import java.util.Date;

public class MySynchronized {
	
	static String now() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d = new Date();
		String now = sdf.format(d);
		//返回时间
		return now;
	}
	//log方法
	static void log(String msg) {
		System.out.printf("%s:%s%s%n",now(),Thread.currentThread().getName(),msg);
	}
	public static void main(String[] args) {
		final Object someObject = new Object();
		
		Thread t1 = new Thread() {
			@Override
			public void run() {
				//进度说明
				log("线程已经运行");
				log("线程试图占有someObject");
				//同步对象
				synchronized (someObject) {//synchronized同步代码块内的代码为关键逻辑代码，需要被保护的，以免产生脏数据
					log("线程占有someObject");
					try {
						Thread.sleep(5000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					log("释放someObject");
				}
			}
		};
		t1.setName("T1");//设置名字
		t1.start();
		
		Thread t2 = new Thread() {
			@Override
			public void run() {
				//进度说明
				log("线程已经运行");
				log("线程试图占有someObject");
				//同步对象
				synchronized (someObject) {
					log("线程占有someObject");
					try {
						Thread.sleep(5000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					log("释放someObject");
				}
			}
		};
		t2.setName("T2");
		t2.start();
	}
}

Lock接口

package lock的使用;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestMyLock {
	//时间
	static String now() {
		SimpleDateFormat sdf = new SimpleDateFormat();
		Date d = new Date();
		String now = sdf.format(d);
		return now;
	}
	
	//简化的说明
	static void log(String msg) {
		System.out.printf("%s:%s%s%n",now(),Thread.currentThread().getName(),msg);
	}
	
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		
		Thread t1 = new Thread() {
			@Override
			public void run() {
				log("线程已经运行");
				log("线程试图占有lock");
				lock.lock();
				log("线程成功占有lock");
				try {
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					log("线程结束");
					//关掉lock
					lock.unlock();
				}
			}
		};
		t1.setName("T1");
		t1.start();
		
		try {
			//让t1飞两秒
			Thread.sleep(2000);
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		
		Thread t2 = new Thread() {
			@Override
			public void run() {
				log("线程已经运行");
				log("线程试图占有lock");
				lock.lock();//lock.lock()与lock.unlock()之间的代码为关键逻辑代码，需要被保护的，以免产生脏数据
				log("线程成功占有lock");
				try {
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					log("线程结束");
					//关掉lock
					lock.unlock();
				}
			}
		};
		t2.setName("T2");
		t2.start();
	}
}

tyyLock()用法

package lock的使用;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestMyTrylock {
	//时间
	static String now() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d = new Date();
		String now = sdf.format(d);
		return now;
	}
	//规范化的输出
	static void log(String msg) {
		
		System.out.printf("%s:%s%s%n",now(),Thread.currentThread().getName(),msg);
	}
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		
		
		Thread t1 = new Thread() {
			@Override
			public void run() {
				boolean loked = false;//记录是否线程占用成功lock对象
				log("线程已经运行");
				log("线程视图占有lock对象");
				try {
					//设置线程最大等待时间两秒
					loked = lock.tryLock(2,TimeUnit.SECONDS);
					if(loked) {
						log("线程占有lock对象,并进行5秒的运算");
						Thread.sleep(5000);
					}else {
						log("线程经过两秒的努力没有成功占有lock对象");
					}
					log("线程结束");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					if(loked) {
						lock.unlock();
					}
				}
			}
		};
		t1.setName("T1");
		t1.start();
		
		Thread t2 = new Thread() {
			@Override
			public void run() {
				boolean loked = false;//记录是否线程占用成功lock对象
				log("线程已经运行");
				log("线程视图占有lock对象");
				try {
					loked = lock.tryLock(2,TimeUnit.SECONDS);
					if(loked) {
						log("线程占有lock对象,并进行5秒的运算");
						Thread.sleep(5000);
					}else {
						log("线程经过两秒的努力没有成功占有lock对象");
					}
					log("线程结束");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					if(loked) {
						lock.unlock();
					}
				}
			}
		};
		t2.setName("T2");
		t2.start();
	}
}

使用lock进行线程交互

package lock的使用;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestMyLock {
	//时间
	static String now() {
		SimpleDateFormat sdf = new SimpleDateFormat();
		Date d = new Date();
		String now = sdf.format(d);
		return now;
	}
	
	//简化的说明
	static void log(String msg) {
		System.out.printf("%s:%s%s%n",now(),Thread.currentThread().getName(),msg);
	}
	
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		//后边释放锁，唤醒其他线程需要使用下边这个类
        Condition condition = lock.newCondition();
        
		Thread t1 = new Thread() {
			@Override
			public void run() {
				log("线程已经运行");
				log("线程试图占有lock");
				lock.lock();
				log("线程成功占有lock");
				try {
					Thread.sleep(5000);
					
					//让线程临时释放锁让其他线程得到lock对象并运行
                    //此处使用lock的释放方法与synchronized略有不同
                    log("线程临时释放锁");
                    condition.await();//释放操作与synchronized的wait()对应
                    log("线程重新获得lock对象进行五秒的操作");
                    Thread.sleep(5000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					log("线程结束");
					//关掉lock
					lock.unlock();
				}
			}
		};
		t1.setName("T1");
		t1.start();
		
		try {
			//让t1先跑两秒
			Thread.sleep(2000);
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		
		Thread t2 = new Thread() {
			@Override
			public void run() {
				log("线程已经运行");
				log("线程试图占有lock");
				lock.lock();//lock.lock()与lock.unlock()之间的代码为关键逻辑代码，需要被保护的，以免产生脏数据
				log("线程成功占有lock并进行5秒的操作");
				try {
					Thread.sleep(5000);
					condition.signal();//唤醒操作与synchronized的notify()对应  还有个signalAll()与notifyAll();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					log("线程结束");
					//关掉lock
					lock.unlock();
				}
			}
		};
		t2.setName("T2");
		t2.start();
	}
}

简单描述synchronized关键字和Lock接口的区别

前者是java关键字是内置语言实现，后者是接口，然后就是lock需要每次结束手动释放锁，否则会造成死锁，再者使用synchronized容易造成死锁，必须代码逻辑严密不出错才能避免死锁，而lock有个trylock（）方式可以设置抢占资源的时间，过了时间自动不抢了，有效避免死锁，然后就是synchronied中线程交互，被占用调用wait(),notify(),notifyAll()均来自Obejct超级父类。而lock接口中使用await(),signal(),signalAll()来自于Condition接口；

dzz_bc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
玩转java多线程 之多线程基础 Lock锁实战练习
weixin_45806131的博客
10-10 425
从JDK5.0开始，java提供了更强大的线程同步机制，通过显式定义同步锁对象来实现同步，同步锁用Lock对象充当。 java.util.concurrent.locks Lock接口是控制多个线程对共享资源进行访问的工具，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得Lock对象。 ReentrantLock类实现了Lock, 它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以
synchronized+习题
qq_64684446的博客
04-05 410
多线程应用之synchronized synchronized在多线程中保证代码的原子性 可见性 和一致性 简单总结: 当修饰实例方法时:相当于对当前对象实例加锁 当修饰静态方法时,相当于对当前类加锁 当修饰代码块时,若synchronized(this)即表示对当前对象加锁,synchronized(类.class)表示对当前类加锁引航站 下边是一个银行转账的小例子 @Data class Account { /** * 此处是共享变量 */ private int c
java关键字synchronized练习
weixin_34405354的博客
05-28 222
2019独角兽企业重金招聘Python工程师标准>>> ...
JUC（八）：synchronized小练习
打工仔~的博客
07-30 201
练习synchronized 对其更加掌握
synchronized和lock的区别 +小练习
江的福，安杰喊你敲代码啦！～
04-03 113
小练习： 首先是一个不太好的示范，虽然结果是正确的，但是很繁琐，且没有灵活发挥condition的作用。 import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import jav...
java基础知识多线程线程池讲解和练习
11-01
线程间的同步和通信是多线程编程的关键，Java提供了synchronized关键字、wait/notify机制以及Lock接口等工具来处理这些问题，防止数据不一致性和死锁的发生。 接着，我们来探讨线程池。线程池是管理线程的一种机制...
线程练习代码下载即测
10-12
Java提供了多种同步机制，如synchronized关键字、Lock接口（ReentrantLock）以及java.util.concurrent包中的工具类。synchronized提供块级或方法级的锁，确保同一时间只有一个线程访问同步代码块。Lock接口提供了更...
Java多线程-线程安全问题练习题
最新发布
01-30
1. **同步机制**：包括`synchronized`关键字和`Lock`接口，用于控制对共享资源的访问，确保同一时间只有一个线程可以执行特定代码块。 2. **volatile关键字**：用于标记共享变量，确保所有线程都能看到该变量的最新...
Java复习资料和练习题.zip
04-15
线程同步和互斥使用synchronized关键字、wait/notify机制、Lock接口（如ReentrantLock）等手段。 9. **反射**：Java反射机制允许在运行时检查类、接口、字段和方法的信息，甚至动态调用方法和修改字段值。 10. **...
javase基础练习代码
05-02
理解同步机制，如synchronized关键字和Lock接口。 10. **枚举与注解**：枚举是一种特殊的类，用于定义有限的固定值。注解则是一种元数据，提供编译器或JVM的附加信息。 11. **泛型**：泛型用于在类、接口和方法中...
java-日常练习-多线程-synchronized详解
上海 彭彭
10-19 158
先举个例子线程不安全的 package a; class Test { public int a=0; public void setValue(String name) throws InterruptedException { if(name.equals("a")){ a=100; Thread.sleep(1000); System.out.println
Java并发练习：synchronize练习简单构造生产者与消费者模型
萌白在努力的博客
04-13 70
目标：synchronize基本功能练习 功能： 上锁、解锁 中断 休眠与唤醒 ReentrantLock同样的实现： 相较于synchronize，ReentrantLock相对灵活更多，特别对于condition与中断以及非阻塞层面。 https://blog.csdn.net/k295330167/article/details/115675185 代码： package com.miracle.study.syn; import java.util.LinkedList; import
synchronized和Lock的秒懂案例
matrixZCL的博客
09-18 234
/** * 只有获得锁对象，才能执行同步代码块。每个线程执行完同步代码块才会释放锁 */ public class Main { public static void main(String[] args) { Ticket ticket=new Ticket();//创建一个Runnable对象，保证调用同一个run方法 new Thread(tic...
模拟买票小练习-线程资源同步小练习-synchronized使用
weixin_47402482的博客
10-26 181
模拟买票练习多线程 使用Thread和Runable练习买票和练习共享资源问题 方式一：继承Thread类 1.首先定义一个ticks变量为总票数为10 2.定义run方法，循环的扣除票数量（简单写一下打印ticks票数） 3.模拟四个窗口购买票 问题1：打印的结果是每个窗口都打印了10张票，也就是说变量tickets没有共享 解决1：通过给变量添加static，使变量变为共享变量如（代码1） 解决2：通过实现runable接口解决共享变量问题（代码2） 问题2：打印的ticks
synchronized实战
只有变秃 才能变强
04-05 990
synchronized synchronized 是最常用的实现同步的手段，在 Java SE 1.6 以及之后的版本，对 synchronized 进行了优化，使 synchronized 整体的性能得到了很大的提升，下面看下 synchronized 的相关实现。 示例 下面是一个基本的使用示例： import java.util.concurrent.ExecutorS...
笔记 - 14 多线程 synchronized CountDownLatch wait notify 练习
qq_45181415的博客
01-03 485
题目1 请利用线程间通信, 完成连续打印1-100的数字, 要求一条线程专门打印奇数,另外一条专门用来打印偶数 要求: 1:数字打印必须是有序的,既1–100的顺序不能乱; 2:必须使用多线程技术; 效果: ​ … 参考答案: public class A { public static int number = 1; public static void main(String[] args) { Object lock = n
Lock接口使用及和synchronized的区别
zlj1217的博客
07-22 416
关于锁的一些知识 可重入锁 如果锁具有可重入性，则称为可重入锁。synchronized和ReentrantLock都是可重入锁。其实可重入锁实际上表明了锁的分配机制：是基于线程的分配还是基于方法调用的分配。 比如代码： class MyClass { public synchronized void method1() { method2(); } public synchronized void method2() {
synchronized和Lock的区别
zhao9tian的专栏
07-15 1771
有区别 所实现的锁功能是一致的，但是 Lock 的功能更为强大一些。 比如 Lock 可以产生多个条件变量，可以实现多个类似于 wait, notifyAll 的等待及唤醒功能。而 synchronized 只有一个条件变量，也就是锁对象的 wait 和 notifyAll
javaSE学习——线程
雷神乐乐的博客
11-14 324
了解线程的相关概念，有习题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值