JAVA基础多线程（3）—竞争条件 原子类 可重入锁

这是原始的程序，没有锁，所以计数器是重复的

public class test {

   public static void main(String[] args){

      

   Counter counter= new Counter();

   Thread t1=new Thread(counter);

   Thread t2=new Thread(counter);

   Thread t3=new Thread(counter);

   t1.start();

   t2.start();

   t3.start();

}



public class Counter implements Runnable{

    private int count;

    public void add() {

                for (int i=0;i<5;i++){

                count++;

                Thread.sleep(100);

                System.out.println(Thread.currentThread().getName()+"计数器："+count);

        }



    public void run() {

        add();

    }

}

结果：

1. 原子类Atomic

就是一组操作对这个数上锁,要么成功要么失败都绑在一块儿，写出来的代码优雅一点

下边是就是一个计数器，用的Atomic，效率会遍高，但是他不会像synchronized那样按顺序的输出，因为如果线程按顺序排队是很慢的。

 

我看结果的时候想了好久，为什么输出的之后是乱序的，因为原子型的是Atomic，但是println不是原子的，println的时候可能count已经变了，就输出乱了。但是计数是没有错的。

public class test {

   public static void main(String[] args){

      

   Counter counter= new Counter();

   Thread t1=new Thread(counter);

   Thread t2=new Thread(counter);

   Thread t3=new Thread(counter);

   t1.start();

   t2.start();

   t3.start();

}



public class Counter implements Runnable{

    private int count;

    public void add() {

                for (int i=0;i<5;i++){

                count++;

                Thread.sleep(100);

                System.out.println(Thread.currentThread().getName()+"计数器："+count);

        }



    public void run() {

        add();

    }

}

 

 

2，synchronized  内部锁，可重入锁

父类有锁，子类继承父类覆盖方法后又重新调用，我们会觉得是锁了2次，但实际并不是。

synchronized是对象锁，在Widget w=new widget();的时候只有一个对象，所以其实是同一把锁。

 

可重入锁：synchronized内部锁的可重入机制，就是说一个对象拿到的这个锁，当别人在拿到这个锁的时候是可以再次进入的。（否则就死锁了）