JUC并发编程(四)

20、各种锁的理解：

公平锁：不能够插队，必须先来后到

非公平锁：可以插队

    Lock lock=new ReentrantLock();//非公平锁

    public ReentrantLock() {
            sync = new NonfairSync();
        }
--------------------------------------------------------------------------------
    Lock lock1=new ReentrantLock(true);//公平锁

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

可重入锁（递归锁）：拿到关键锁以后就可以自动获得其他锁

synchronized：

![捕获1](../../捕获1.PNGpackage com.huang.Lock02;

public class 可重入锁 {
    public static void main(String[] args) {
        Phone01 phone01=new Phone01();
        new Thread(()->{
            phone01.sms();
        },"A").start();

        new Thread(()->{
            phone01.sms();
        },"B").start();
    }
}
class Phone01{
    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName()+"------"+"sms");
        call();
    }
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"------"+"call");
    }
}

ReentrantLock：(lock锁是配对的有几个lock 就有几个unlock)

package com.huang.Lock02;

import com.sun.corba.se.impl.resolver.SplitLocalResolverImpl;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class 可重入锁Lock {
    public static void main(String[] args) {
        Phone02 phone02=new Phone02();

        new Thread(()->{
            phone02.sms();
        },"A").start();

        new Thread(()->{
            phone02.sms();
        },"B").start();
    }
}
class Phone02{
    Lock lock=new ReentrantLock();
    Condition condition1=lock.newCondition();
    Condition condition2=lock.newCondition();
    public  void sms(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"------"+"sms");
            call();
            condition1.await();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            condition2.signal();
            lock.unlock();
        }
    }
    public  void call(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"------"+"call");
            condition2.await();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            condition1.signal();
            lock.unlock();
        }
    }
}

自旋锁（利用Cas，CAS是cup的并发原语）：

自定义自旋锁：

package com.huang.Lock02;

import java.util.concurrent.atomic.AtomicReference;

public class MySpinLock {
    AtomicReference<Thread> atomicReference=new AtomicReference<>();
    public void lock(){
        Thread thread=Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"--->"+"MyLock");
        while (!atomicReference.compareAndSet(null,thread)){

        }

    }
    public void  unlock(){
        Thread thread=Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"--->"+"MyUnLock");
    }

}

测试：

package com.huang.Lock02;

import java.util.concurrent.TimeUnit;

public class PinkLockTest {
    public static void main(String[] args) {
        MySpinLock lock=new MySpinLock();
        new Thread(()->{
            lock.lock();
            try {
                TimeUnit.SECONDS.sleep(2);
            }catch (Exception e){

                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"T1").start();
        new Thread(()->{
            lock.lock();
            try {
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"T2").start();
    }
}

死锁()：

代码：

package com.huang.Lock02;

import java.util.concurrent.TimeUnit;

public class DeadLock {
    public static void main(String[] args) {
        String lockA="lockA";
        String lockB="lockB";
        new Thread(new MyThead(lockA,lockB),"T1").start();
        new Thread(new MyThead(lockB,lockA),"T2").start();
    }

}
class MyThead implements Runnable{

    private String lockA;
    private String lockB;

    public MyThead(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+lockA+"-->"+lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+lockA+"-->"+lockB);
            }
        }


    }
}

解决死锁：

1、jps 解决jps -l

2、查看进程信息jstack

面试：

1、日志文件

nchronized (lockB){
System.out.println(Thread.currentThread().getName()+lockA+"–>"+lockB);
}
}

}

}

解决死锁：

**1、jps  解决`jps -l`**

**2、查看进程信息`jstack`**

面试：

1、日志文件

2、查看堆栈信息