线程安全变量及关键字

1、synchronized关键字，代表这个方法加锁,相当于不管哪一个线程（例如线程A），运行到这个方法时,都要检查有没有其它线程B（或者C、 D等）正在用这个方法(或者该类的其他同步方法)，有的话要等正在使用synchronized方法的线程B（或者C 、D）运行完这个方法后再运行此线程A,没有的话,锁定调用者,然后直接运行。它包括两种用法：synchronized 方法和 synchronized 块。

2、volatile

一个类型 修饰符（type specifier），就像大家更熟悉的const一样，它是被设计用来修饰被不同线程访问和修改的 变量。 volatile的作用是作为指令 关键字，确保本条指令不会因 编译器的优化而省略，且要求每次直接读值。

volatile的变量是说这变量可能会被意想不到地改变，这样， 编译器就不会去假设这个变量的值了。

3、AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减。

使用场景

AtomicInteger提供原子操作来进行Integer的使用，因此十分适合高并发情况下的使用

package com.java.my;

import com.java.my.service.testService;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author wanjiadong
 * @description
 * @date Create in 9:53 2018/1/31
 */
public class test1 {
    static AtomicInteger count = new AtomicInteger(0);

    static int n = 0;

    public static void main(String[] args) throws Exception {
        //第一种newInstance实例一个对象，通常与forName()配合使用
//        testService t = (testService) Class.forName("com.java.my.service.testService").newInstance();
//        String str = t.checkName("ff");
//
//        //使用反射
//        Class<?> c = Thread.currentThread().getContextClassLoader().loadClass("com.java.my.service.testService");
//        Object cStr = c.getMethod("checkName",String.class).invoke(c.newInstance(),"ff");
//        System.out.println(cStr.toString());
        //System.out.println(count.get());
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        myThread1.start();
        myThread2.start();

        Thread.sleep(10000);
        System.out.println("count最终执行结果为"+count.get());
        System.out.println("n最终执行结果为"+n);
    }

    static class MyThread extends Thread {
        public void run(){
            for(int i=0;i<10000;i++){
                for(int j=0;j<5;j++){
                    count.incrementAndGet();
                    n++;
                    System.out.println("count="+count.get());
                    System.out.println("n="+n);
                }
            }
        }
    }
}

4、ReentrantLock

package com.java.my;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author wanjiadong
 * @description
 * @date Create in 15:48 2018/2/1
 */
public class test3 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        ReentrantLock lock = new ReentrantLock();
        Condition con =  lock.newCondition();

        Runnable run = new Runnable() {
            @Override
            public void run() {
                System.out.println("pre:"+lock.toString());
                lock.lock();
                try {
                    con.await(5, TimeUnit.SECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("post:"+lock.toString());
                    lock.unlock();
                }
            }
        };

        for (int i=0;i<4;i++){
            executorService.execute(run);
        }
        executorService.shutdown();
    }

}