线程安全_线程安全 dirty code-CSDN博客

本文链接：https://blog.csdn.net/liangzelei/article/details/80677225

线程安全概念

当多个线程访问某一个类（对象或者方法）时，这个类始终都能表现正确的行为，那么这个类（对象或者方法）就是线程安全的
synchronized
synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”

public class HelloWorld extends Thread {
	
	private int count = 5;
	
	public synchronized void run() {
		count--;
		System.out.println(Thread.currentThread().getName() + " count = " + count);
	}
	public static void main(String[] args) {
		HelloWorld hw1 = new HelloWorld();
		Thread t1 = new Thread(hw1, "t1");
		Thread t2 = new Thread(hw1, "t2");
		Thread t3 = new Thread(hw1, "t3");
		Thread t4 = new Thread(hw1, "t4");
		Thread t5 = new Thread(hw1, "t5");
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
	}
}

当多个线程访问对象方的方法时，以排队的方式进行处理（这里排队的是按照CPU分配的先后顺序而定的），一个线程想要执行synchronized修饰的方法里的代码，首先要尝试获得锁，如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）

多个线程多个锁

多个线程，每个线程都可以拿到自己指定的锁，分别获得锁之后，执行synchronized方法体的内容。

public class MultiThread {
	/* static */
	private int num = 0;
	/* static */
	public synchronized void printNum(String tag) {
		if(tag.equals("a")) {
			num = 100;
			System.out.println("tag a set num over!");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} else {
			num = 200;
			System.out.println("tag b set num over!");
		}
		System.out.println("tag" + tag + ", num = " + num);
	}
	
	public static void main(String[] args) {
		final MultiThread m1 = new MultiThread();
		final MultiThread m2 = new MultiThread();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				m1.printNum("a");
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				m2.printNum("b");
			}
		}, "t2");
		t1.start();
		t2.start();
	}
}

关键字synchronized取得的锁都是对象锁，而不是一段代码（方法）当作锁，所以实例代码中那个线程先执行synchronized关键字的方法，那个线程就持有该方法所属对象的锁（Lock），两个对象，线程获得的就是两个不同的锁，他们互不影响。有一种情况是相同的锁，即在静态方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）

对象锁的同步和异步

同步：synchronized
同步的概念就是共享，如果不是共享的资源，没有必要同步
异步：asynchronized
异步的概念就是独立，互相之间不受任何约束，就好象在页面发起ajax请求时，我们还可以继续浏览或操作页面的内容，二者之间没有任何关系。

同步目的就是为了线程安全，其实对于线程安全来说，需要满足两个特性： 原子性（同步）、可见性
脏读
对于对象的同步和异步的方法，我们在设计自己的程序的时候，一定要考虑问题的整体，不然就会出现数据不一致的错误，很经典的错误就是脏读（dirtyread）

在我们对一个对象的方法加锁的时候，需要考虑业务的整体性，即为setValue/getValue方法同时加锁synchronized同步关键字，保证业务（service）的原子性，不然会出现业务错误（也从侧面保证业务的一致性）

synchronized锁重入

关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到了一个对象的锁后，再次请求对象时可以再次得到该对象的锁

volatile关键字的概念

volatile概念：volatile关键字的主要作用是使变量在多个线程间可见
在Java中，每一个线程都有一块工作内存区，其中存放着所有线程共享的主内存中的变量值的拷贝。当线程执行时，它在自己的工作内存区中操作这写变量。为了存取一个共享的变量，一个线程通常先获取锁定并去清除它的内存工作区，把这些共享变量从所有线程的共享内存区中正确的装入到自己所在的工作区内存中，当线程解锁时保证该工作内存区中变量的值写回到共享内存中
要注意的是volatile关键字只具有可见性，没有原子性。要实现原子性建议使用atomic类的系列对象，支持原子性操作（注意atomic类只保证本身方法原子性，并不保证多次操作的原子性）