夜光带你走进 Java 成神之路（四十一）擅长的领域

带你走进 Java 成神之路（四十一）擅长的领域"/>

夜光带你走进 Java 成神之路（四十一）擅长的领域

夜光序言：

 

 

我都舍不得欺负的人，哪能让别人欺负?

 

 

 

 

 

 

 

 

 

 

正文：

                           以道御术 / 以术识道

 

 

 

 

package 深入理解volatile原理与使用;//保证可见性的前提
//多个线程拿到的是同一把锁，否则是保证不了的
public class Demo {//volatile保证线程的一致性public volatile int a = 1; //变量上面加上一个volatilepublic synchronized int getA() {  //这里加上一把锁return a;}public synchronized void setA(int a) {  //这里加上一把锁try {Thread.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}this.a = a;}//一个线程在get，另外一个线程在set，很大情况下会出现线程安全问题public static void main(String[] args) {//我们先new一个对象出来Demo d = new Demo();d.a = 10;new Thread(new Runnable() {@Overridepublic void run() {System.out.println(d.a);}}).start();try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("最终的结果为：" + d.getA());}}

 

package 深入理解volatile原理与使用;public class Demo2 {//volatile关键词保证一下public volatile boolean run = false;public static void main(String[] args) {Demo2 demo2 = new Demo2();new Thread(new Runnable() {@Overridepublic void run() {for (int i=1;i<=10;i++){System.err.println("执行了第" + i + "次");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}demo2.run = true;}}).start();//第二个线程new Thread(new Runnable() {@Overridepublic void run() {while(!demo2.run){//不执行}System.err.println("线程2执行了~~");}}).start();}}

 

package Lock接口认识和使用;import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;//夜光
public class Sequence {private int value;Lock lock = new ReentrantLock(); //使用这个就可以了public int getNext(){  //相当于一个门，加一把锁lock.lock();int a = value++;lock.unlock(); //释放锁return value++;}public static void main(String[] args) {//我们调用的时候
//        new Sequence().getNext();//1. 下面这种方式面对多线程，会出现不可预期的问题
//        Sequence s = new Sequence();
//        while(true){ //多次调用
//            System.out.println(s.getNext());
//        }//2. 我们看看下面这种方式Sequence s = new Sequence();new Thread(new Runnable() {@Overridepublic void run() {//下面，我们不停地去调用生成器while (true){System.out.println(Thread.currentThread().getName()+""+s.getNext());try {Thread.sleep(1000);  //休息一会儿} catch (InterruptedException e) {e.printStackTrace();}}}}).start();//然后，我们重写多个//嗯唔//第二个线程new Thread(new Runnable() {@Overridepublic void run() {//下面，我们不停地去调用生成器while (true){System.out.println(Thread.currentThread().getName()+""+s.getNext());try {Thread.sleep(1000);  //休息一会儿} catch (InterruptedException e) {e.printStackTrace();}}}}).start();//第三个线程new Thread(new Runnable() {@Overridepublic void run() {//下面，我们不停地去调用生成器while (true){System.out.println(Thread.currentThread().getName()+""+s.getNext());try {Thread.sleep(1000);  //休息一会儿} catch (InterruptedException e) {e.printStackTrace();}}}}).start();}}

 

package 自旋锁死锁重入锁.可重入锁;import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;public class MyLock implements Lock {//怎么判断第一个哈private boolean isLocked = false;@Overridepublic synchronized void lock() {  //我们加上这个关键词，进来的线程要等待while (isLocked)  //只要为true，就~//.....try {wait();} catch (InterruptedException e) {e.printStackTrace();}isLocked = true;}//第一个资源执行完毕，需要释放锁//那么我们则@Overridepublic synchronized void unlock() {  //synchronized必须要加上这个isLocked = false;notify();}@Overridepublic void lockInterruptibly() throws InterruptedException {}@Overridepublic boolean tryLock() {return false;}@Overridepublic boolean tryLock(long time, TimeUnit unit) throws InterruptedException {return false;}@Overridepublic Condition newCondition() {return null;}
}

package 自旋锁死锁重入锁.可重入锁;//Sequence,我们写一个这个
public class Sequence {private MyLock lock = new MyLock(); //我们先构建一下~private int value;public int getNext(){lock.lock();value++;lock.unlock();return value;}public static void main(String[] args) {Sequence s = new Sequence();//现在，我们进行一下测试,夜光：三个线程new Thread(new Runnable() {@Overridepublic void run() {System.out.println(s.getNext());}}).start();new Thread(new Runnable() {@Overridepublic void run() {System.out.println(s.getNext());}}).start();new Thread(new Runnable() {@Overridepublic void run() {System.out.println(s.getNext());}}).start();}}

 

 

 

上面表示不可重入

 

那么下面，我们改成可重入的

可重入的锁，需要记住当下的线程

 

package 自旋锁死锁重入锁.可重入锁;//我们说这个锁是可以重入的，我们来写一个例子
public class Demo {MyLock lock = new MyLock();public void a(){lock.lock();System.out.println("a");//这里，我们调用b方法b();lock.unlock();}public void b(){lock.lock();System.out.println("b");lock.unlock();}//然后，我们来测试public static void main(String[] args) {Demo d = new Demo();//然后，我们来创建线程//嗯唔//我们只要调用a就可以了，因为a里面包含了bnew Thread(new Runnable() {@Overridepublic void run() {d.a();}}).start();//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                d.b();
//            }
//        }).start();}}

 

 

package 自旋锁死锁重入锁.可重入锁;//Sequence,我们写一个这个
public class Sequence {private MyLock lock = new MyLock(); //我们先构建一下~private int value;public int getNext(){lock.lock();value++;lock.unlock();return value;}public static void main(String[] args) {Sequence s = new Sequence();//现在，我们进行一下测试,夜光：三个线程new Thread(new Runnable() {@Overridepublic void run() {while (true)System.out.println(s.getNext());}}).start();new Thread(new Runnable() {@Overridepublic void run() {while (true)  //我们加上一个这个System.out.println(s.getNext());}}).start();new Thread(new Runnable() {@Overridepublic void run() {while (true)System.out.println(s.getNext());}}).start();}}

 

package 自旋锁死锁重入锁.可重入锁;import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;public class MyLock implements Lock {//怎么判断第一个哈private boolean isLocked = false;//为了实现可重入锁//我们进行必要的改造//首先，需要记住当下的线程private Thread lockBy = null; //有点帅//锁的数量private int lockCount = 0;@Overridepublic synchronized void lock() {  //我们加上这个关键词，进来的线程要等待Thread currentThread = Thread.currentThread();//嗯唔while (isLocked && currentThread != lockBy)  //只要为true，就~//.....try {wait();} catch (InterruptedException e) {e.printStackTrace();}isLocked = true;lockBy = currentThread;lockCount++; //递增}//第一个资源执行完毕，需要释放锁//那么我们则@Overridepublic synchronized void unlock() {  //synchronized必须要加上这个if (lockBy == Thread.currentThread()){  //如果是相等的lockCount--;if (lockCount == 0){notify();isLocked = false;}}}@Overridepublic void lockInterruptibly() throws InterruptedException {}@Overridepublic boolean tryLock() {return false;}@Overridepublic boolean tryLock(long time, TimeUnit unit) throws InterruptedException {return false;}@Overridepublic Condition newCondition() {return null;}
}