java 学习 进阶之 一 （线程基础）

一、线程安全

线程安全的概念：当多个线程访问某一个类（对象或方法）时。这个类始终都能表现出正确的行为那么这个类（对象或方法）就是线程安全的。

synchronized：可以在任何对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”

示例：【com.study.base.thread.a_sync.sync001】MyThread

package com.study.base.thread.a_sync.sync001;
/**
 * 
 *        线程安全概念：当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法）
 *    就是线程安全的
 *        synchronized:可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”
 *    
 *    示例总结
 *        当多个线程访问myThread的run方法时，以排队的方式进处理（这里排队是按照CPU分配的先后顺序商定的），
 *    一个线程想要执行Synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；
 *    拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁（也就是会有锁竞争的问题）。
 */
public class MyThread implements Runnable {
    private int count = 5;
    
    //synchronized 加锁
    public synchronized void run() {
        count--;
        System.out.println(Thread.currentThread().getName()+" count = "+count);
    }
    
    public static void main(String[] args) {
        /**
         *     分析：
         *         当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排队是按照cpu分配的先后顺序而定的）
         *         1  尝试获得锁
         *         2 如果拿到锁，执行synchronized代码体内容：拿不到锁出，这个线程就会不断的尝试获得这把锁，直到拿到为止
         *         而且是多个线程同时去竞争这把锁，也就是会有锁竞争的问题
         */
        MyThread mythread = new MyThread();
        Thread t1 = new Thread(mythread,"t1");
        Thread t2 = new Thread(mythread,"t2");
        Thread t3 = new Thread(mythread,"t3");
        Thread t4 = new Thread(mythread,"t4");
        Thread t5 = new Thread(mythread,"t5");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
         
    }
}
MyThread

示例总结

    当多个线程访问myThread的run方法时，以排队的方式进处理（这里排队是按照CPU分配的先后顺序商定的），一个线程想要执行Synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁（也就是会有锁竞争的问题）。

二、多个线程多个锁

多个线程多个锁：多个线程，每个线程都可以拿到自己指定的锁分别获得锁之后执行synchronized方法体的内容

示例：【com.study.base.thread.a_sync.sync002】MultiThread

package com.study.base.thread.a_sync.sync002;
/**
 *     多个线程多个锁：多个线程，每个线程都可以拿到自己指定的锁分别获得锁之后执行synchronized方法体的内容
 *        关键字synchronized获取的锁都是对象锁，而不是把一段代码（方法）当做锁，所以示例代码中哪个线程先执行synchronized关键字的方法，哪个线下就持有该方法所属对象的锁（Lock），两个对象。线程获得的就是两个不同的锁，他们互不影响
 *    有一种情况则是相同的锁，即使在静态方法上加synchronized关键字，表示锁定.class，类一级别的锁（独占.class类）.
 */
public class MultiThread {
    private int num = 0;
    public synchronized void printNum(String tag) {
        try {
            if(tag.equals("a")) {
                num = 100;
                System.out.println("tag a , set num over");
                Thread.sleep(1000);
            } else {
                num = 200 ;
                System.out.println("tag b , set num over");
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("tag "+tag+" , num = "+num);
    }
    //注意观察run方法的输出顺序
    public static void main(String[] args) {
        //两个不同的对象
        final MultiThread m1 = new MultiThread();
        final MultiThread m2 = new MultiThread();
        
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                m1.printNum("a");
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                m2.printNum("b");
            }
        },"t2");
        t1.start();
        t2.start();
    }
}
MultiThread

示例总结

    关键字synchronized获取的锁都是对象锁，而不是把一段代码（方法）当做锁，所以示例代码中哪个线程先执行synchronized关键字的方法，哪个线下就持有该方法所属对象的锁（Lock），两个对象。线程获得的就是两个不同的锁，他们互不影响 有一种情况则是相同的锁，即使在静态方法上加synchronized关键字，表示锁定.class，类一级别的锁（独占.class类）.

三、对象锁的同步和异步

同步：synchronized 同步的概念就是共享，我们要牢牢记住“共享”这两个字，如果不是共享的资源，就没有必要进行同步

异步：asynchronized 异步的概念就是独立，相互之间不受到任何制约。就好像我们学习http的时候，在页面发起的Ajax请求,我们还可以继续浏览操作页面的内容，两者之间没有任何关系

同步的目的就是为了线程安全，其实对于线程安全来说，需要满足两个特性：

　　原子性（同步）

　　可见性

示例：【com.study.base.thread.a_sync.sync003】MyObject

 

package com.study.base.thread.a_sync.sync003;
/**
 * 
 * 对象的同步和异步问题
 *
 */
public class MyObject {
    public synchronized void method1() {
        try {
            System.out.print(Thread.currentThread().getName());
            Thread.sleep(4000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /** synchronized */
    public void method2() {
        System.out.println(Thread.currentThread().getName());
    }
    
    public static void main(String[] args) {
        final MyObject mo = new MyObject();
        /**
         * 分析：
         * t1线程先持有object对象的lock锁，t2线程可以以异步的方式调用对象中的非synchronized修饰的方法
         * t1线程先持有object对象的lock锁，t2线程如果在这个时候调用对象中的同步（synchronized）方法则需等待，也就是同步
         */
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                mo.method1();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                mo.method2();
            }
        },"t2");
        t1.start();
        t2.start();
    }
}
MyObject

 

示例总结

    A线程先持有object对象的Lock锁，B线程如果在这个时候调用对象的同步（synchronized）方法则需要等待，也就是同步 ​

    A线程先持有object对象的Lock锁，B线程可以以异步的方式调用对象中的非synchronized修饰的方法

四、脏读

    对于对象的同步和异步方法，我们在设计自己的程序的时候，一定要考虑问题的整体，不然会出现数据不一致的错误，很经典的错误就是脏读（dirtyread）

示例：【com.study.base.thread.a_sync.sync004】DirtyRead

package com.study.base.thread.a_sync.sync004;

/**
 * 业务整体需要使用完整的synchronized，保持业务的原子性
 * 
 *
 */
public class DirtyRead {
    private String username = "Rang";
    private String password = "123";
    public synchronized void setValue(String username, String password) {
        this.username = username;
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        this.password = password;
        
        System.out.println("setValue最终结果, username = " + username + " password = " + password);
    } 
    
    public synchronized void getValue() {
        System.out.println("getValue方法得到, username = " + username + " password = " + password);
    }
    
    public static void main(String[] args) throws InterruptedException {
        
        final DirtyRead dr = new DirtyRead();
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                dr.setValue("z3", "456");
            }
            
        },"t1");
        t1.start();
        Thread.sleep(1000);
        
        dr.getValue();
        
    }
            
}
DirtyRead

示例总结：

    在我们对一个对象的方法加锁的时候，需要考虑业务的整体性，即为setValue / getValue 方法同时加锁synchronized同步的关键字，保证业务（service）的原子性，不然会出现业务错误（也从侧面保证业务的一致性）。

 五、synchronized 其他概念

synchronized锁重入：关键字synchronized拥有锁重入的功能，也就是使用synchronized时，当一个线程得到一个对象的锁后，再次请求此对象时是可以再次得到该对象的锁的。

示例：【com.study.base.thread.a_sync.sync005】SyncDubbo1

package com.study.base.thread.a_sync.sync005;
/**
 * synchronized 的重入
 *
 */
public class SyncDubbo1 {
    public synchronized void method1() {
        System.out.println("method1......");
        method2();
    }
    public synchronized void method2() {
        System.out.println("method2......");
        method3();
    }
    public synchronized void method3() {
        System.out.println("method3......");
    }
    public static void main(String[] args) {
        final SyncDubbo1 sa = new SyncDubbo1();
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                sa.method1();
            }
        });
        t1.start();
    }
    
}
SyncDubbo1

示例：【com.study.base.thread.a_sync.sync005】SyncDubbo2

package com.study.base.thread.a_sync.sync005;
/**
 * synchronized 的重入
 *
 */
public class SyncDubbo2 {
    
    static class Main{
        public int i = 10;
        public synchronized void operationSup() {
            try {
                i--;
                System.out.println("Main print i = "+i);
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 有父子继承关系的 互相之间调用有synchronized修饰的方法也是线程安全的
     *
     */
    static class Sub extends Main{
        public synchronized void operationSub() {
            try {
                while (i > 0) {
                    i--;
                    System.out.println("Sub print i = "+i);
                    Thread.sleep(100);
                    this.operationSup();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
     
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                 Sub sub = new Sub();
                 sub.operationSub();
            }
        });
        t1.start();
    }
    
}
SyncDubbo2

示例：【com.study.base.thread.a_sync.sync005】SyncException

package com.study.base.thread.a_sync.sync005;
/**
 * synchronized 异常
 * 异常之后  前后是一个整体时  抛出异常 回滚
 * 前后不是一个整体没有关联关系的话 记录日志 continue 执行下个循环
 */
public class SyncException {
     
    private int i = 0 ;
    public synchronized void operation() {
        while (true) {
            try {
                i++;
                Thread.sleep(200);
                System.out.println(Thread.currentThread().getName()+", i = "+i);
                if (i == 10) {
                    Integer.parseInt("a");
                    //throw new RuntimeException();
                }
            } catch (Exception e) { //InterruptedException
                e.printStackTrace();
                System.out.println(" log  info i = "+i);
                //throw new RuntimeException
                //continue;
            }
        }
    }
     
    public static void main(String[] args) {
        final SyncException se = new SyncException();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                se.operation(); 
            }
        },"t1");
        t1.start();
    }
    
}
SyncException

示例说明：

    对于web应用程序。异常释放锁的情况，如果不及时处理，很可能对你的应用程序业务逻辑产生严重的错误，比如你现在执行一个队列任务，很多对象都去在等待第一个对象正常执行完毕再去释放锁。但是第一个对象由于异常的出现，导致业务逻辑没有正常执行完毕，就释放了锁。那么可想而知后续的对象执行的都是错误的逻辑。所以这一点一定要引起注意，在编写代码的时候，一定要考虑周全

六、synchronized 代码块

使用synchronized声明的方法在某些情况下是有弊端的，比如A线程调用同B线程就必须等待比较长的时间才能执行，这样的情况下可以使用synchronized代码块去优化代码执行时间，也就是通常所说的减小锁的粒度。

示例：【com.study.base.thread.a_sync.sync006】Optimize

 

package com.study.base.thread.a_sync.sync006;
import com.study.util.DateUtil;
/**
 *    使用synchronized声明的方法在某些情况下是有弊端的，比如A线程调用同B线程就必须等待比较长的时间才能执行，
 *    这样的情况下可以使用synchronized代码块去优化代码执行时间，也就是通常所说的减小锁的粒度
 */
public class Optimize {
     
    public synchronized void method1 () {
        System.out.println("当前线程："+Thread.currentThread().getName()+" 开始 "+DateUtil.getCurrentTimes());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("当前线程："+Thread.currentThread().getName()+" 结束"+DateUtil.getCurrentTimes());
    }
    public void method2 () { 
        System.out.println("当前线程："+Thread.currentThread().getName()+" 开始"+DateUtil.getCurrentTimes());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        synchronized (this) {
            System.out.println("当前线程："+Thread.currentThread().getName()+" 执行锁代码块开始"+DateUtil.getCurrentTimes());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("当前线程："+Thread.currentThread().getName()+" 执行锁代码块结束"+DateUtil.getCurrentTimes());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("当前线程："+Thread.currentThread().getName()+" 结束"+DateUtil.getCurrentTimes());
    }
    
    public static void main(String[] args) {
        final Optimize optimize = new Optimize(); 
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                optimize.method1();
                //optimize.method2();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                optimize.method1();
                //optimize.method2();
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}
Optimize

 

synchronized可以使用任意的Object进行加锁，用法比较灵活。

 

示例：【com.study.base.thread.a_sync.sync006】ObjectLock

 

package com.study.base.thread.a_sync.sync006;
/**
 * 使用synchronized代码块加锁，比较灵活
 */
public class ObjectLock {
     
    /**
     *    对象锁
     */
    public void method1() {
        synchronized (this) { //对象锁
            try {
                System.out.println("do method1...");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     *     类锁
     */
    public void method2() {
        synchronized (ObjectLock.class) { //类锁
            try {
                System.out.println("do method2...");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    private  Object lock = new Object();
    /**
     *     任何对象都会锁
     */
    public void method3() {
        synchronized (lock) { //任何对象
            try {
                System.out.println("do method3...");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        final ObjectLock objLock = new ObjectLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method1();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method2();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method3();
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
    
}
ObjectLock

 

另外特别注意一个问题，就是不要使用String的常量加锁，会出现死循环问题。

示例：【com.study.base.thread.a_sync.sync006】StringLock

package com.study.base.thread.a_sync.sync006;
/**
 * synchronized 代码块对字符串的锁，注意String常量池的缓存功能
 */
public class StringLock {
      
    public void method() {
        //new String ("字符串常量")
        synchronized ("字符串常量") {  // 在常量池中 "字符串常量" 只有一个引用
            try {
                while(true) {
                    System.out.println("当前线程："+Thread.currentThread().getName() +"开始");
                    Thread.sleep(1000);
                    System.out.println("当前线程："+Thread.currentThread().getName() +"结束");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String []  args) {
        final StringLock stringLock = new StringLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                stringLock.method();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                stringLock.method();
            }
        },"t2");
        t1.start();
        t2.start();
    }
    
}
StringLock

锁对象的改变问题。当使用一个对象进行加锁的时候，要注意对象本身发生改变的时候，那么持有的锁就不同。如果对象本身不发生改变，那么依然是同步的，即使是对象的属性发生了改变。

示例：【com.study.base.thread.a_sync.sync006】ChangeLock

package com.study.base.thread.a_sync.sync006;
/**
 * 锁对象的改变问题
 */
public class ChangeLock {
      
    private String lock = "lock";
    
    public void method() {
        synchronized (lock) {  // 在常量池中 "字符串常量" 只有一个引用
            try {
                while(true) {
                    System.out.println("当前线程："+Thread.currentThread().getName() +"开始");
                    lock = "change lock";  // 修改后锁发生变化了 锁将不在有效  。如果想锁生效不要在方法里修改锁对象的引用
                    Thread.sleep(2000);
                    System.out.println("当前线程："+Thread.currentThread().getName() +"结束");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String []  args) {
        final ChangeLock changeLock = new ChangeLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                changeLock.method();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                changeLock.method();
            }
        },"t2");
        t1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         t2.start();
    }
    
}
ChangeLock

示例：【com.study.base.thread.a_sync.sync006】ModifyLock

package com.study.base.thread.a_sync.sync006;
/**
 *    同一对象属性的修改不会影响锁的情况
 */
public class ModifyLock {
      
    private String name ;
    
    private int age ;
    
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public synchronized void changeAttribute(String name, int age ) {
        try {
            System.out.println("当前线程："+Thread.currentThread().getName() +"开始");
            this.setName(name);
            this.setAge(age);
            System.out.println("当前线程："+Thread.currentThread().getName() +" 修改对象内容为"
                    +this.getName()+", "+this.getAge());
            Thread.sleep(2000);
            System.out.println("当前线程："+Thread.currentThread().getName() +"结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String []  args) {
        final ModifyLock modifyLock = new ModifyLock(); // 对象锁  一个对象一个锁
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                modifyLock.changeAttribute("张三", 18);
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                modifyLock.changeAttribute("李四", 21);
            }
        },"t2");
        t1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         t2.start();
    }
    
}
ModifyLock

死锁问题

示例：【com.study.base.thread.a_sync.sync006】DeadLock

package com.study.base.thread.a_sync.sync006;
/**
 *    死锁问题 : 比较常见的死锁的产生是因为A线程执行需要得到B线程的占用锁  B线程执行的时候需要A线程占用的锁
 **/
public class DeadLock {
    
    public static void main(String[] args) {
        final Object a = new Object();
        final Object b = new Object();
        
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                synchronized(a) {
                    System.out.println("t1线程获取到锁a了");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("t1线程准备获取锁b");
                    synchronized(b) {
                        System.out.println("t1线程获取到锁b了");
                    } 
                    
                } 
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                synchronized(b) {
                    System.out.println("t2线程获取到锁b了");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("t2线程准备获取锁a");
                    synchronized(a) {
                        System.out.println("t2线程获取到锁a了");
                    } 
                } 
                
            }
        },"t2");
        t1.start();
        t2.start();
        
    }
}
DeadLock

七、volitail关键字的使用

Volatile概念：volatile关键字的主要作用是使变量在多个线程间可见。

示例：【com.study.base.thread.a_sync.sync007】

package com.study.base.thread.a_sync.sync007;
/**
 * volatile关键字的主要作用是使变量在多个线程间可见
 *
 */
public class RunThread extends Thread {
    /**
     * volatile
     */
    private boolean isRunning  = true;
    
    private void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }
    
    public void run() {
        System.out.println("进入run方法");
        while(isRunning == true) {
            //..
        }
        System.out.print("线程停止");
    }
    public static void main(String[] args) throws InterruptedException {
        RunThread rt = new RunThread();
        rt.start();
        Thread.sleep(3000);
        rt.setRunning(false);
        System.out.println("isRunning设置成立false");
        Thread.sleep(1000);
        System.out.println(rt.isRunning);
    }
}
RunThread

示例总结：

    在java中，每一个线程都会有一块工作内存区，其中存放着所有线程共享的主内存中的变量值的拷贝。当线程执行时，他在自己的工作内存区中操作这些变量。为了存取一个共享的变量，一个线程通常先获取锁定并去清除它的内存工作区，把这些共享变量从所有线程的共享内存区中正确的装入到他自己所在的工作内存区中，当线程解锁时保证该工作内存区中的变量的值写回到共享内存中。

    一个线程可以执行的操作有​使用（use）、 赋值（asslgn）、装载（load）、存储（store）、锁定（lock）、解锁（unlocK）

    而主内存可以执行的操作有读（read）、写（write）、锁定（lock）、解锁（unlock）每个操作都是原子的

    volatile的作用就是强制线程到主内存（共享内存）里去读取变量，而不去线程工作的内存区里去读取，从而实现了线程之间的变量可见，也就满足线程安全的可见性​​​

volatile关键字虽然拥有多个线程之间的可见性，但是却不具有同步性（也就是原子性），可以算上是一个轻量及的synchronized ，性能要比synchronized强很，不会照成阻塞（在很多开源的架构里），比如netty的底层代码就大量使用volatile，可见netty性能一定是非常不错的）这里需要注意：一般volatile用于只针对多个线程可见的变量操作，并不能代替synchronized的同步功能。

示例：【com.study.base.thread.a_sync.sync007】VolatileNoAtomic

package com.study.base.thread.a_sync.sync007;
/**
 * Volatile 关键字不具备synchronized关键字的原子性（同步）
 * @author Administrator
 *
 */
public class VolatileNoAtomic extends Thread {
    private static volatile int count;
    //private static AtomicInteger count = new AtomicInteger(0);
    
    
    private static void addCount() {
        for (int i = 0; i < 1000; i++) {
            count++;
            //count.incrementAndGet();
        }
        System.out.println(count);
    }
    
    public void run() {
        addCount();
    }
    
    public static void main(String[] args) throws InterruptedException {
        VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
        for (int i = 0; i < 10; i++) {
            arr[i] = new VolatileNoAtomic();
        }
        
        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
        //最后一次打印10000才是对的 中间可以忽略 （因为可能第一次循环1000次完成以后 后面的线程也在执行++ 导致数据在中间打印的不是完整的1000）。
        //如果想要保持原子性推荐使用 AtomicInteger
        //CAS非阻塞算法
    }
}
VolatileNoAtomic

示例总结：

     volatile关键字只具有可见性，没有原子性。要实现原子性建议使用Atomic类的系列对象，支持原子性操作（注意Atomic类只能保证本身方法的原子性，并不保证多次操作原子性）

示例：【com.study.base.thread.a_sync.sync007】AtomicUse

package com.study.base.thread.a_sync.sync007;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicUse {
    private AtomicInteger count = new AtomicInteger(0);
    
    //多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修缮，保证4个addAndGet整体原子性
    /** synchronized */
    public synchronized int multiAdd() {
        try {
            Thread.sleep(100);    
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count.addAndGet(1);
        count.addAndGet(2);
        count.addAndGet(3);
        count.addAndGet(4);// +10
        return count.get();
    }
    
    public static void main(String[] args) {
        final AtomicUse au = new AtomicUse();
        
        List<Thread> ts = new ArrayList<Thread>();
        for (int i = 0; i < 100; i++) {
            ts.add(new Thread(new Runnable() {
                
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    System.out.println(au.multiAdd());
                }
            }));
        }
        for (Thread t : ts) {
            t.start();
        }
    }
}
AtomicUse

示例总结：

　　在多线程中同一个方法中多次调用atomic类中的方法，不能保证这个的方法中多次调用atomic类的方法（整体的）原子性，如果想保证此方法中多次调用atomic类的方法（整体的）原子性的那么需要添加synchronized关键字，否者最终结果可能是一致但是中间返回的数据可能不是满10（见示例）

    

posted @ 2019-11-03 23:32  青青一笑很倾城  阅读(292)  评论(0)    收藏  举报