为了结局数据原子性问题
我们引入基于CAS机制的
原子变量类,来进行保证共享数据的原子性。
package org.example.testjul;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
//设计一个计数器,所有的系统中的线程访问了系统之后,都可以用
public class Indicator {
private static final Indicator INSTANCE = new Indicator();//定义一个私有的本类静态对象
public static Indicator getINSTANCE() {
return INSTANCE;
}
private Indicator(){
}
private final AtomicLong requestCount = new AtomicLong(0);//请求总数
private final AtomicLong successCount = new AtomicLong(0);//请求成功
private final AtomicLong fialureCount = new AtomicLong(0);//请求失败
//处理成功情况,处理成功的加加
public void requestProcess(){
requestCount.incrementAndGet();//相当于增加
}
//
public void successCount(){
successCount.incrementAndGet();
}
public void failureCount(){
//统计失败的请求总数
fialureCount.incrementAndGet();
}
public long getRequestCount(){
return requestCount.get();
}
public long getSuccessCount(){
return successCount.get();
}
public long getFialureCount(){
return fialureCount.get();
}
}
使用方法进行介绍。
API使用。
关于乐观锁和悲观锁
独占锁是一种悲观锁,而 synchronized 就是一种独占锁,synchronized 会导致其它所有未持有锁的线程阻塞,而等待持有锁的线程释放锁。
**所谓乐观锁就是,每次不加锁而是假设没有冲突而去完成某项操作,如果更新数据之前,验证一下,有没有冲入,如果因为冲突失败就重试,直到成功为止。而乐观锁用到的机制就是CAS。**
LOCK锁
可重入性锁
已经获得了锁对象,再次请求时候还是能获得锁。
、
相当于我拿着一把锁进了两个们,这种感觉
说白了,就是被同一把锁锁住的们,我都可以进去,我拿着锁都可以进去。
可以发现没发生死锁,可以多次获取相同的锁
可重入锁有
synchronized
ReentrantLock
使用ReentrantLock的注意点
ReentrantLock 和 synchronized 不一样,需要手动释放锁,所以使用 ReentrantLock的时候一定要手动释放锁,并且加锁次数和释放次数要一样
reentrantLock方法,获得和释放锁
使用方法介绍。
package org.example.testjul;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test1 {
static Lock lock = new ReentrantLock();
public static void sm(){
lock.lock();;
for(int i = 0;i < 100;i++){
System.out.println(Thread.currentThread().getName() + "--" + i);
}
lock.unlock();//释放锁
//这个锁就是比较灵活,我可以选择那些部分被锁住,那些不被锁住
}
public static void main(String[] args) {
Runnable r = new Runnable(){
@Override
public void run(){
sm();
}
};
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
}
}
unlock锁可以用于同步不同方法中的同步代码块。
经常和try和fiinally联合使用
毕竟你必须要释放锁
Lock和synchorized的区别和异同。
https://blog.csdn.net/hefenglian/article/details/82383569
package org.example.testjul;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test1 {
static Lock lock = new ReentrantLock();
public static void sm1(){
try{
lock.lock();
System.out.println(Thread.currentThread().getName() + "-- method1 -- " + System.currentTimeMillis() );
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally{
lock.unlock();
}
//这个锁就是比较灵活,我可以选择那些部分被锁住,那些不被锁住
}
public static void sm2(){
try{
lock.lock();//同一个锁对象lock能够锁住同一批同步代码块
//只要使用了同一个锁对象,不管同步代码块在哪里,都可以被一把锁锁住
System.out.println(Thread.currentThread().getName() + "-- method1 -- " + System.currentTimeMillis() );
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally{
lock.unlock();
}
//这个锁就是比较灵活,我可以选择那些部分被锁住,那些不被锁住
}
public static void main(String[] args) {
Runnable r = new Runnable(){
@Override
public void run(){
sm1();
}
};
Runnable r1 = new Runnable() {
@Override
public void run() {
sm2();
}
};
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
new Thread(r1).start();
new Thread(r1).start();
new Thread(r1).start();
//同一把锁,把sm2和sm1两个方法都给锁住了
}
}
这些东西都可以实现同步
使用这个锁时候可以考虑静态化,静态化实际上是将整个变量变成所有类公用,这样两个对象就可以公用一把锁了。
可重入锁表示可以反复获得这个锁
那么,就一定要释放两次
这里重点是,一个静态对象,是属于全类的,那么就可以拿来作为整个类的锁。
如果当前线程没被中断,那么就可以直接获得锁
如果收到了来自psvm的中断标志,那么就抛出异常
就像如果你没被下封杀命令,那么就可以正常出入境内外,如果下了,那么就不行。
注意这里
给t2线程一个中断标志
那么执行到t2线程时候,t2线并不会获取到锁
但是对t1没影响,t1还是可以正常获取到锁。
相当于告诉你,没希望了,别等了,别傻傻等待了。
当线程长时间未响应时候,可以让线程停止等待。
可以让线程停止等待。
实际开发时候中断其中一个线程就可以解决死锁问题
Lock就是显示锁,可以解决锁的死锁问题
synchnorized是内部锁,内部锁并不可以解决死锁问题。
lock和synchnorized区别
https://blog.csdn.net/qq_37807989/article/details/93380526
可以使用tryLoc方法解决线程死锁问题
毕竟上一个解决方法里,有一个问题
我们要等待多少秒之后将哪一个死锁线程给关掉呢?
tryLock方法本质就是限时等待,在一定时间内,没有获取到锁那么这个线程也不会去进行等待,而是结束,说白了就是追女神有个时间限制,规定时间内没追到就结束了。
package org.example.testjul;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test1 {
public static void main(String[] args) {
new TimeThread().start();
new TimeThread().start();
//第一个线程获得锁,将持有6秒,第二个线程启动3秒后没有获得锁,自动结束,不会等待
}
private static class TimeThread extends Thread{
private static ReentrantLock reentrantLock = new ReentrantLock();
@Override
public void run(){
try {
if(reentrantLock.tryLock(3, TimeUnit.SECONDS)){
//等待3秒后没获得锁
System.out.println(Thread.currentThread().getName() + "获得所");
Thread.sleep(30000);
}
else{
System.out.println("没有获得锁");
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
if(reentrantLock.isHeldByCurrentThread()){
//如果线程被当前线程持有
reentrantLock.unlock();//那么就释放了
}
}
}
}
}
trylock不加参数,就是无限去等待。
线程中NewCondition方法
可以实现等待通知模式。
newContition可以选择性的根据条件变化随机唤醒一个线程。
await方法和signal方法就很像同步代码块里
this.wait和notify
package org.example.testjul;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test1 {
private static Lock lock = new ReentrantLock();//获得一把锁
static Condition condition = lock.newCondition();//用这把锁创建一个condition对象
//总结起来就是,你首先要有一把锁,第二你从这把锁中衍生出来一个条件对象用于让东西去等待
private static class SubThread extends Thread{
@Override
public void run(){
try {
lock.lock();//调用await之前必须先获得锁
System.out.println("method lock");
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();//线程释放锁
}
System.out.println("method await");//进入线程等待状态
}
}
public static void main(String[] args) {
new SubThread().start();
//子线程很快进入沉睡状态,如果某个线程比如主线程要去叫醒这个线程,那么必须首先获得锁
//你要救出沉睡的公主,你首先要有公主房间的钥匙
//await方法已经把锁吐出来了,你要做的就是获得这把锁
lock.lock();
condition.signal();//叫醒线程
lock.unlock();
}
}
不过我觉得这个东西最厉害的地方还是
一个点
lock可以锁住好多个线程
然后同一lock可以创造出好多个condition对象
然后这些对象可以一人锁住一个线程
就相当于这个锁可以诞生很多儿子
儿子一人锁住一个线程,需要时候唤醒指定condition下的就可以了。
package org.example.testjul;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test1 {
//总结起来就是,你首先要有一把锁,第二你从这把锁中衍生出来一个条件对象用于让东西去等待
private static class SubThread{
private static Lock lock = new ReentrantLock();//获得一把锁
static Condition condition1 = lock.newCondition();//用这把锁创建一个condition对象
static Condition condition2= lock.newCondition();//第二个条件
static Condition condition3 = lock.newCondition();//第三个可以沉睡线程东西
public void waitA(){
try {
lock.lock();
System.out.println("A获得了锁");
System.out.println("condition1等待");
condition1.await();//第一线程进入等待
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("condition1被唤醒了");
}
public void waitB(){
try {
lock.lock();
System.out.println("B获得了锁");
System.out.println("condition2等待");
condition2.await();//第一线程进入等待
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("condition2被唤醒了");
}
public void waitC(){
try {
lock.lock();
System.out.println("C获得了锁");
System.out.println("condition3等待");
condition1.await();//第一线程进入等待
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("condition3被唤醒了");
}
public void notigyA(){
lock.lock();
System.out.println("notify1获得了锁,并且要唤醒A");
condition1.signal();//唤醒condition下被沉睡的线程
lock.unlock();
}
public void notifyC(){//唤醒C线程
lock.lock();
System.out.println("notify3获得了锁,并且要唤醒C");
condition3.signal();
lock.unlock();
}
}
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
new SubThread().waitA();//A让A和B睡眠
new SubThread().waitB();
new SubThread().waitC();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
new SubThread().notigyA();//只唤醒A
new SubThread().notifyC();//只唤醒C
}
}).start();
}
}
可以单独唤醒指定线程。
可以用来进行线程交替打印
package org.example.testjul;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test1 {
//总结起来就是,你首先要有一把锁,第二你从这把锁中衍生出来一个条件对象用于让东西去等待
private static class SubThread{
private static Lock lock = new ReentrantLock();//获得一把锁
static Condition condition1 = lock.newCondition();//用这把锁创建一个condition对象
static Condition condition2= lock.newCondition();//第二个条件
private static int flag = 1;//flag = 1时候让线程1打印1,打印完了自己沉睡然后让标志位变成2
//标志位为2让线程2醒来打印2
public static void thread1Print(){
try {
lock.lock();//获得锁
while(flag == 2){
condition1.await();//当flag == 2自己就沉睡了
}
System.out.println(1);//flag == 1时候正常打印
flag = 2;//flag2
condition2.signal();//叫醒2,状态变化了老兄
}
catch (Exception e){
}
finally {
lock.unlock();
}
}
public static void thread2Print(){
try {
lock.lock();//获得锁
while(flag == 1){
condition2.await();//当flag == 1自己就沉睡了,用条件2让自己沉睡
}
System.out.println(2);//flag == 1时候正常打印
flag = 1;//flag2
condition1.signal();//叫醒1,状态变化了老兄
}
catch (Exception e){
}
finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
while(true){
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 100;i++){
SubThread.thread1Print();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
SubThread.thread2Print();
}
}
}).start();
}
}
}
公平锁和非公平锁
大多数情况下,锁都是非公平锁。
大部分锁都是非公平锁
就是线程随机从阻塞队列中拿出来一个,而不是按照时间先后顺序
能按照排队时间先后顺序拿到锁的才是公平锁。
非公平锁会出现线程饥饿问题,问题很多线程永远抢不到,就会饥饿,公平锁不会饥饿,因为永远有机会抢到。
synchronized就是非公平锁,毕竟是内部锁
lock有公平锁的机制,毕竟是显示锁
reentrantLock(boolean fair)提供一个实现公平锁的机会
package org.example.testjul;
import java.util.concurrent.locks.ReentrantLock;
public class Test11 {
static ReentrantLock reentrantLock = new ReentrantLock(true);//创建Lock锁
//这个状态下就是公平锁
public static void main(String[] args) {
for(int i = 0;i < 19;i++){
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
reentrantLock.lock();
System.out.println(Thread.currentThread().getName() + "获得了线程");
reentrantLock.unlock();
}
});
thread.setName(i + "");
thread.start();
}
//公平锁会让所有线程都去获得一次锁,平均分配
}
}
每个线程都有机会抢到一次cpu执行权。
package org.example.testjul;
import java.util.concurrent.locks.ReentrantLock;
public class Test11 {
static ReentrantLock reentrantLock = new ReentrantLock(true);//创建Lock锁
//这个状态下就是公平锁
public static void main(String[] args) {
for(int i = 0;i < 19;i++){
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while(true){
//让一个线程不断的占有和释放锁
reentrantLock.lock();
System.out.println(Thread.currentThread().getName() + "获得了线程");
reentrantLock.unlock();
}
}
});
thread.setName(i + "");
thread.start();
}
//公平锁会让所有线程都去获得一次锁,平均分配
}
}
这种一个线程不断抢到锁,释放锁,抢到锁释放锁的线程,面对的最大问题就是不断的有的线程会长期持有锁,不会别人用,别人很难得到,就是线程饥饿状态。
所以需要公平锁,让每个线程都根据等待时间有机会去得到锁。
getHoldCount可以显示出调用lock的次数。
getQueueLength()返回的是等待的线程数量,等着拿锁的线程数量
返回这个条件下正在wait状态,等待唤醒的线程数量
直接将线程装进数组里,然后根据Lock去判断这个线程是不是在等待锁。
查询这个条件是不是在沉睡了某个线程。
还可以设置沉睡时间。。
判断锁是不是被当前线程持有。