java 同步线程方式

Java并发编程包含三个基本概念:

• 原子性：一（多）个操作要么全部执行要么不执行，中途不会被打断；
• 可见性：一个线程对某变量的修改对其他线程来说是可见的，即能知道值进行过修改；
• 有序性：程序执行按照代码的顺序执行；

线程安全问题的本质：

在多个线程访问共同的资源时，在某⼀个线程对资源进⾏写操作的中途（写⼊已经开始，但还没结束），其他线程对这个写了⼀半的资源进⾏了读操作，或者基于这个写了⼀半的资源进⾏了写操作，导致出现数据错误。

锁机制的本质：

通过对共享资源进⾏访问限制，让同⼀时间只有⼀个线程可以访问资源，保证了数据的准确性。

1.同步方法

使用synchronized关键字

	public static void main(String[] args){
        Increase increase = new Increase();
        int count = 10;
        while (count != 0){
            new Thread(() -> {
                increase.increasementAndPrint();
            }).start();
            count --;
        }
	}
    
	//保证原子性和有序性
	static class Increase {
        private int i = 0;
        synchronized void increasementAndPrint() {
            System.out.println(i++);
        }
    }

2.同步代码块

//保证原子性和有序性
static class Increase {
    private int i = 0;
    void increasementAndPrint(Increase.class) {
     	synchronized(){
     		System.out.println(i++);
     	}
    }
}

3.使用特殊域变量(volatile)实现线程同步

//不保证原子性（一个被volatile声明的变量主要有可见性，有序性）
static class Increase {
    private volatile int i = 0;

    void increasementAndPrint() {
        System.out.println(i++);
    }
}

4.使用重入锁实现线程同步

//保证原子性和有序性
static class Increase {
    private Lock lock = new ReentrantLock();
    private  int i = 0;

    void increasementAndPrint() {
        lock .lock();
       	try {
	      	x++;
		} finally {
			lock.unlock();
		}
    }
}

⼀般并不会只是使⽤ Lock，⽽是会使⽤更复杂的锁，例如ReadWriteLock：

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
Lock readLock = lock.readLock();
Lock writeLock = lock.writeLock();
private int x = 0;

private void count() {
	writeLock.lock();
	try {
		x++;
 	} finally {
		writeLock.unlock();
 	}
}

private void print(int time) {
	readLock.lock();
	try {
	for (int i = 0; i < time; i++) {
		System.out.print(x + " ");
 	}
		System.out.println();
 	} finally {
		readLock.unlock();
 	}
}

5.使用局部变量实现线程同步

static class Increase {
    private  int i = 0;

 	private static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue() {
            // TODO Auto-generated method stub
            return 0;
        }
    };
    
    void increasementAndPrint() {
        count.set(count.get()+(i++));
        System.out.println(i++);
    }
}

6.使用阻塞队列实现线程同步

• 前面5种同步方式都是在底层实现的线程同步，但是我们在实际开发当中，应当尽量远离底层结构。
  使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。
  使用LinkedBlockingQueue来实现线程的同步,LinkedBlockingQueue是一个基于已连接节点的，范围任意的blocking queue。

7.使用原子变量实现线程同步

• 需要使用线程同步的根本原因在于对普通变量的操作不是原子的。
  那么什么是原子操作呢？
  原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作
  即-这几种行为要么同时完成，要么都不完成。
  在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，
  使用该类可以简化线程同步。
  java.util.concurrent.atomic包下⾯有 AtomicInteger AtomicBoolean 等类，作⽤和 volatile 基本
  ⼀致，可以看做是通⽤版的 volatile。

AtomicInteger atomicInteger = new AtomicInteger(0);
...
atomicInteger.getAndIncrement();

补充:

1.控制线程的并发访问数

	static Semaphore semaphore = new Semaphore(5);
	//信号池，permit信号池中的信号数量，线程必须拿到permit才能继续向下走，否则等待
	public static void main(String[] args) {
		for (int i = 0; i < 30; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					try {
						semaphore.acquire();//从信号池中获取一个permit,如果没有获取到就等待，直到拿到permit
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					test();
					semaphore.release();//将permit放回信号池中
				}
			}).start();
		}
	}
	//TODO 控制方法的线程访问数为5
	public static void test() {
		System.out.println("--thread name--" + Thread.currentThread().getName()
				+ "进来了");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("--thread name--" + Thread.currentThread().getName()
				+ "出去了");
	}