线程安全变量及关键字

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/baidu_20608025/article/details/79225839

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();
    }

}


展开阅读全文

没有更多推荐了,返回首页