JAVA 并发----记录1
package com.shob.syn; public class SharaData { private static int count = 0; /** * 并发测试 * 共享性:多线程下共享数据问题 */ private static void sha(){ final SharaData data = new SharaData(); for (int i = 0; i < 10; i++) { new Thread(new Runnable() { @Override public void run() { try { //进入的时候暂停1毫秒,增加并发问题出现的几率 Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } for (int j = 0; j < 100; j++) { data.add(); } System.out.println(count+" "); } }).start(); } try { //主程序暂停3秒,以保证上面的程序执行完成 Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("count=" + count); } /** * 并发测试 * 互斥性:同时只允许一个访问者对其进行访问,具有唯一性和排它性 * 通常我们允许多个线程对数据进行读操作,但是同一时间只允许一个线程对数据进行写操作 * 这种通常叫为共享锁和排它锁,或者读锁和写锁。 * 如果资源不具有互斥性,也不需要担心线程安全。 * 对于不可变的数据共享,所有线程都只能对其进行读操作,所以不用考虑线程安全问题。 * 但是对共享数据的写操作,一般就需要保证互斥性 */ private static void shasyn(){ final SharaData data = new SharaData(); for (int i = 0; i < 10; i++) { new Thread(new Runnable() { @Override public void run() { try { //进入的时候暂停1毫秒,增加并发问题出现的几率 Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } for (int j = 0; j < 100; j++) { data.addsyn(); } System.out.println(count+" "); } }).start(); } try { //主程序暂停3秒,以保证上面的程序执行完成 Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("count=" + count); } private void add(){ count++; } private synchronized void addsyn(){ count++; } /** * 原子性:指对数据的操作是一个独立的、不可分割的整体。换句话说,就是一次操作,是一个连续不可中断的过程 * 数据不会执行一半的时候被其他线程所修改。 * 保证原子性的最简单方式是操作系统指令,就是说如果一次操作对应一条操作系统指令,这样肯定能保证原子性。 * 但是很多操作不能通过一条指令来完成。 * * 例如:long类型的运算,很多系统需要分成多条指令分别对高位和低位进行操作才能完成。 * 还比如,我们经常使用的整数 i++ 的操作,其实需要分成三个步骤: * (1)读取整数 i 的值;(2)对 i 进行加一操作;(3)将结果写回内存。 */ private void oi(){ /** * 对于这种组合操作,要保证原子性,最常见的方法就是加锁。如Synchronized or Lock * * 除了锁以外,还有一种方式就是CAS(Compare And Swap), * 即修改数据之前先比较与之前读取到的值是否一致,如果一致,则进行修改,如果不一致则重新执行。 * 这也是乐观锁的实现原理。 * * 不过CAS在某些场景下不一定有效,比如另一线程先修改了某个值,然后再改回原来值,这种情况下,CAS是无法判断的。 */ } //----------------------------------------------------------------------------------- /** * 可见性: */ private void see(){ /** * 每个线程都有一个自己的工作内存(相当于CPU高级缓冲区,这么做的目的还是在于进一步缩小存储系统与CPU之间速度的差异,提高性能), * 对于共享变量,线程每次读取的是工作内存中共享变量的副本,写入的时候也直接修改工作内存中副本的值, * 然后在某个时间点上再将工作内存与主内存中的值进行同步。 * 这样导致的问题是,如果线程1对某个变量进行了修改,线程2却有可能看不到线程1对共享变量所做的修改。 */ } /** * jvm 内存模型 */ private void jvm(){ /** * * 线程一 线程二 * || || * || || * V V * 线程一工作内存 线程二工作内存 * 共享变量副本 共享变量副本 * || || * || || * V V * 共享变量 共享变量 * 主内存 * */ } private static boolean ready;//默认false private static int number; private static class ReaderThread extends Thread { public void run() { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } if (!ready) { System.out.println(ready); } System.out.println(number); } } private static class WriterThread extends Thread { public void run() { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } number = 100; ready = true; } } /** * 有序性:为了提高性能,编译器和处理器可能会对指令做重排序。 * 重排序可分为三种: * 1、编译器优化的重排序。编译器在不改变单线程程序语义的前提下,可以重新安排语句的执行顺序。 * 2、指令级并行的重排序。现代处理器采用了指令级并行技术(Instruction-Level Parallelism, ILP)来将多条指令重叠执行。 * 如果不存在数据依赖性,处理器可以改变语句对应机器指令的执行顺序。 * 3、内存系统的重排序。由于处理器使用缓存和读/写缓冲区,这使得加载和存储操作看上去可能是在乱序执行。 * Java 中也可通过Synchronized或Volatile来保证顺序性。 * @param args */ private void xu(){ } public static void main(String[] args) { //shasyn(); //偶尔会出线打印true 100 /** * 当然,这个结果也只能说是有可能是可见性造成的,当写线程(WriterThread)设置ready=true后, * 读线程(ReaderThread)看不到修改后的结果,所以会打印false, * 对于第二个结果,也就是执行if (!ready)时还没有读取到写线程的结果,但执行System.out.println(ready)时读取到了写线程执行的结果。 * 不过,这个结果也有可能是线程的交替执行所造成的。 * Java 中可通过Synchronized或Volatile来保证可见性, */ new WriterThread().start(); new ReaderThread().start(); } }