java语言基础--线程相关类

            public
            final
            int getAndAddInt(Object var1, long var2, int var4) {
            int var5;
            do {
                var5 = this.getIntVolatile(var1, var2);
            } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));//将当前工作线程传入的值与主内存的值比较，如果相同 就返回var5与var4之和return var5;
        }

            //
            如果是expect   那么更新为 update
            public
            final
            boolean
             compareAndSet(V expect, V update) {
        
            return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }

            public
            class
             ATomICExample1 {
    
            //
            指定为ATomICExample1的count字段
            private
            static AtomicIntegerFieldUpdater<ATomICExample1> updater =  AtomicIntegerFieldUpdater.newUpdater(ATomICExample1.class, "count");

    publicvolatileint count = 100;//这里必须使用volatile 来修饰publicstaticvoid main(String[] args) {

        ATomICExample1 example5 = new ATomICExample1();

        if (updater.compareAndSet(example5, 100, 120)) {
            System.out.println(example5.getCount());//输出120        }

        if (updater.compareAndSet(example5, 100, 120)) {
            System.out.println(example5.getCount());
        } else {
            System.out.println(example5.getCount());//输出120        }
    }
    publicint getCount() {
        return count;
    }

    publicvoid setCount(int count) {
        this.count = count;
    }
}

            public
            class
             ATomICExample1 {
    
            private
            static AtomicBoolean isHappened = new AtomicBoolean(false);
    // 请求总数publicstaticint clientTotal = 5000;
    // 同时并发执行的线程数publicstaticint threadTotal = 200;
    publicstaticvoid main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    test();
                    semaphore.release();
                } catch (Exception e) {
                    System.out.println(e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("isHappened:"+ isHappened.get());
    }

    privatestaticvoid test() {
        if (isHappened.compareAndSet(false, true)) {
            System.out.println("execute");
        }
    }
}

            public
            class
             ATomICExample1 {
    
            //
             修饰一个代码块 作用的对象是this
            public
            void test1(int j) {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.println("test1 {} - {}"+ j+""+ i);
            }
        }
    }

    // 修饰一个方法  作用的对象是调用方法的对象publicsynchronizedvoid test2(int j) {
        for (int i = 0; i < 10; i++) {
            System.out.println("test1 {} - {}"+ j+""+ i);
        }
    }

    publicstaticvoid main(String[] args) {
        ATomICExample1 example1 = new ATomICExample1();
        ATomICExample1 example2 = new ATomICExample1();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> {
            example1.test2(1);
        });
        executorService.execute(() -> {
            example2.test2(2);
        });
    }
}

            public
            class
             ATomICExample1 {
    
            //
             修饰一个类
            public
            static
            void test1(int j) {
        synchronized (ATomICExample1.class) {
            for (int i = 0; i < 10; i++) {
                System.out.println("test1 {} - {}"+ j+"--"+ i);
            }
        }
    }
    // 修饰一个静态方法publicstaticsynchronizedvoid test2(int j) {
        for (int i = 0; i < 10; i++) {
            System.out.println("test1 {} - {}"+ j+"--"+ i);
        }
    }
    publicstaticvoid main(String[] args) {
        ATomICExample1 example1 = new ATomICExample1();
        ATomICExample1 example2 = new ATomICExample1();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> {
            example1.test1(1);
        });
        executorService.execute(() -> {
            example2.test1(2);
        });
    }
}

            public
            class
             UnsafePublish {

    
            private String[] states = {"a", "b", "c"};

    public String[] getStates() {
        return states;
    }

}

publicclass Test {
    publicstaticvoid main(String[] args) {
        UnsafePublish unsafePublish = new UnsafePublish();
        System.out.println(Arrays.toString(unsafePublish.getStates()));
        unsafePublish.getStates()[0] = "d";
        System.out.println(Arrays.toString(unsafePublish.getStates()));
    }
}

            public
            class
             SingletonExample2 {

    
            //
             私有构造函数
            private
             SingletonExample2() {

    }

    
            //
             单例对象
            private
            static SingletonExample2 instance = new SingletonExample2();

    // 静态的工厂方法publicstatic SingletonExample2 getInstance() {
        return instance;
    }
}

            public
            class
             SingletonExample4 {
    
            //
             私有构造函数
            private
             SingletonExample4() {
    }
    
            //
             单例对象
            private
            static SingletonExample4 instance = null;
    // 静态的工厂方法publicstatic SingletonExample4 getInstance() {
        if (instance == null) { // 双重检测机制        // B
            synchronized (SingletonExample4.class) { // 同步锁if (instance == null) {
                    //这里的新建对象分三步 ，1 分配对象的内存空间，2 初始化对象 ，3设置instance指向刚分配的内存
                    //第二步和第三步符合cpu指令重排的条件，所以有可能真正的执行步骤是 1->3->2,这样当其他线程来执行if (instance == null)时得到的结果将是false，存在线程安全的问题
                    instance = new SingletonExample4(); 
                }
            }
        }
        return instance;
    }
}

            public
            class
             SingletonExample4 {
    
            //
             私有构造函数
            private
             SingletonExample4() {
    }
    
            //
             单例对象  加上volatile+双锁检验 限制指令重排可以达到线程安全
            private
            static
            volatile SingletonExample4 instance = null;
    // 静态的工厂方法publicstatic SingletonExample4 getInstance() {
        if (instance == null) { // 双重检测机制        // B
            synchronized (SingletonExample4.class) { // 同步锁if (instance == null) {
                    instance = new SingletonExample4(); 
                }
            }
        }
        return instance;
    }
}

            public
            class
             SingletonExample6 {
    
            //
             私有构造函数
            private
             SingletonExample6() { }
    
            //
             单例对象 这里的静态域如果和下面的静态块代码顺序调换将会导致实例化失败 空指针异常，静态代码块和静态域是按照声明顺序执行的，这与普通方法是不一样的
            private
            static SingletonExample6 instance = null;
    static {
        instance = new SingletonExample6();
    }
    // 静态的工厂方法publicstatic SingletonExample6 getInstance() {
        return instance;
    }
    publicstaticvoid main(String[] args) {
        System.out.println(getInstance().hashCode());
        System.out.println(getInstance().hashCode());
    }
}

            public
            class
             ImmutableExample1 {
    
            private final static Integer a = 1;
    private final static String b = "2";
    private final static Map<Integer, Integer> map = Maps.newHashMap();
    static {
        map.put(1, 2);
        map.put(3, 4);
        map.put(5, 6);
    }
    publicstaticvoid main(String[] args) {
//        a = 2;
//        b = "3";
//        map = Maps.newHashMap();
        map.put(1, 3);
    }
    privatevoid test(final Map<Integer, Integer> map) {
//        map = Maps.newHashMap();    }
}

            public
            class
             ImmutableExample2 {
    
            private
            static Map<Integer, Integer> map = Maps.newHashMap();
    static {
        map.put(1, 2);
        map.put(3, 4);
        map.put(5, 6);
        map = Collections.unmodifiableMap(map);
    }
    publicstaticvoid main(String[] args) {
        map.put(1, 3);
    }
}