juc 6 结束

14.1.3 原子性引用

package com.cjg.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

public class demo02 {
   static AtomicStampedReference<Integer> asr = new AtomicStampedReference<>(10, 1);
    public static void main(String[] args) {

        new Thread(()->{
            int stamp = asr.getStamp();
            System.out.println(stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(asr.compareAndSet(10, 1, asr.getStamp(), asr.getStamp() + 1));
            System.out.println("a2=>"+asr.getStamp());
            System.out.println(asr.compareAndSet(1, 10, asr.getStamp(), asr.getStamp() + 1));
            System.out.println("a3=>"+asr.getStamp());

        },"a").start();



        new Thread(()->{
            int stamp = asr.getStamp();
            System.out.println(stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(asr.compareAndSet(10, 16, stamp, stamp+1));
            System.out.println("b2=>"+asr.getStamp());

        },"b").start();
    }
}

15 锁 详解

15.1.1 公平索 非公平锁

• 公平索 不可插队
• 非公平锁 可以插队 默认为非公平锁

public ReentrantLock() {
    sync = new NonfairSync();
}
//方法重载 ture即为公平索
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

15.1.2 可重入锁 递归锁

Syn版 先当与一把锁

package com.cjg.lock;

public class demo01 {
    public static void main(String[] args) {
        phone phone = new phone();
        new Thread(()->{
            phone.qq();
        }).start();
    }
}
class phone{
    public synchronized void call(){
        System.out.println("call");
    }

    public synchronized void qq(){
        System.out.println("qq");
        call();
    }
}
//输出qq call

lock版本 lock相当于两把锁并且需要 同锁同解锁 不然会卡住

package com.cjg.lock;

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

public class demo02 {
    public static void main(String[] args) {
        phone1 phone = new phone1();
        new Thread(()->{
            phone.qq();
        }).start();
    }
    }


class phone1{
    private Lock lock =new ReentrantLock();
    public synchronized void call(){
        lock.lock();
        try {
        System.out.println("call"); }
        catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public synchronized void qq(){
        lock.lock();
        try {
            System.out.println("qq");
            call();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

15.1.3 自旋锁

spinlock

自写自旋锁

package com.cjg.lock;

import java.util.concurrent.atomic.AtomicReference;

public class skiplock {
    //创建一个原子性线程  这里锁
    AtomicReference<Thread> aT = new AtomicReference<>();
    public void lock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"==lock");
       while (!aT.compareAndSet(null,thread)){

       }
    }

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

}

测试

package com.cjg.lock;

import java.util.concurrent.TimeUnit;

public class demo03 {
    public static void main(String[] args) throws InterruptedException {
        skiplock skiplock = new skiplock();
        new Thread(()->{
            skiplock.lock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                skiplock.unlock();
            }
        },"a").start();
        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            skiplock.lock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                skiplock.unlock();
            }
        },"b").start();

    }
}

15.1.4 死锁

互相抢夺资源

怎么排除死锁:

创建死锁

package com.cjg.lock;

import java.util.concurrent.TimeUnit;

public class deadLock {
    public static void main(String[] args) {
        dead dead = new dead("a", "b");
        dead dead1 = new dead("b", "a");
        new Thread(dead).start();
        new Thread(dead1).start();
    }
}
class dead implements  Runnable{

    private String a;
    private String b;

    public dead(String a, String b){
        this.a=a;
        this.b=b;
    }

    @Override
    public void run() {
        synchronized (a){
            System.out.println(a+"==>"+b);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (b){

            }
        }

    }
}

第一步 jps -l 找出 问题提的进程

第二部 jstack 加线程号

看日志

看堆栈信息