Java多线程并发笔记01 对象锁 & 类锁 & 对象锁的同步和异步 & 脏读

例子程序01：对象锁

/**
 * 多线程同时修改同一对象的成员变量，保持修改的原子性
 * @author 超轶绝尘
 *
 */
public class MyThread extends Thread {
	private int count = 5;
	
	
	//synchronized给当前对象加锁
	@Override
	public synchronized void run() {
		count--;
		System.out.println(this.currentThread().getName() + " count = " + count);
	}
	
	public static void main(String[] args) {
		/**
		 * 分析：当多个线程访问myThread方法时，以排队的方式进行处理（这里排队是按照cpu分配的先后顺序而定的）
		 * 一个线程想要执行synchronized关键字修饰的方法里的代码：
		 * 	1.尝试获得锁
		 *  2.如果拿到锁，执行synchronized代码体内容，拿不到锁，这个线程就不断地尝试获得这把锁，直到拿到为止
		 *    而且多个线程同时取竞争这把锁（也就是会有锁竞争问题）
		 */
		MyThread myThread = new MyThread();
		Thread t1 = new Thread(myThread,"t1");
		Thread t2 = new Thread(myThread,"t2");
		Thread t3 = new Thread(myThread,"t3");
		Thread t4 = new Thread(myThread,"t4");
		Thread t5 = new Thread(myThread,"t5");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
	}
}

例子程序02：类锁

不同对象不同的锁，但是对于static修饰的方法，锁的是同一个Class,不是普通对象，所以多线程访问不同对象却拥有相同的锁

/**
 * 
 * 不同对象不同的锁
 * 但是对于static修饰的方法，锁的是Class,不是对象，所以不同对象相同的锁

 * synchronized关键字	取得的锁都是对象锁，而不是把一段代码（方法）当作锁
 * 所以代码中哪个线程先执行synchronized关键字，哪个线程就持有该方法所属对象的锁（Lock）
 * 在静态方法上加上synchronized关键字，表示锁定Class类的对象，类一级别的锁，（独占.class类）
 *
 */

public class MultiThread
{
	
	/*static*/
	private static int num = 0;
	
	/*static*/
	public static synchronized void printNum(String tag) {
		try{
			if(tag.equals("a")) {
				num = 100;
				System.out.println("tag a, set number over!");
				Thread.sleep(1000);
			} else {
				num = 200;
				System.out.println("tag b, set number over!");
			}
			
			System.out.println("tag " + tag + ", num = " + num);
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	//注意观察	run方法输出的顺序
	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");
			}
		});
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() { 
				m2.printNum("b");
			}
		});
		
		t2.start();
		t1.start();
	}
}

例子程序03：对象锁的同步和异步

同步的概念就是共享，如果不共享资源，就没有必要进行同步

             同步的目的是为了线程安全，只要保证2点：

                      1.原子性

                      2.可见性

异步的概念是独立，互相之间没有制约

 

/**
 * 对象锁的同步和异步
 */
public class MyObject {
	
	/** 同步方法 */
	public synchronized void method1() {
		try {
			System.out.println(Thread.currentThread().getName());
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	
	/** 异步方法 */
	public void method2() {
		System.out.println(Thread.currentThread().getName());
	}
	
	public static void main(String[] args) {
		//加锁的话，也是加了1把锁，因为只有1个对象。锁是对象锁
		final MyObject mo = new MyObject();
		
		/***
		 * 分析：
		 * 	t1线程先持有object对象的Lock锁，t2线程可以以异步的方式调用对象中的非synchronized修饰的方法
		 *  t1线程先持有object对象的Lock锁，t2线程如果在这个时候调用	对象中的同步（synchronized）方法则需等待，也就是同步
		 */
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				mo.method1();
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				//method2不需要等待锁，直接就执行了；但是method2则需要等待t1释放锁，4秒后
				mo.method1();
				
			}
		},"t2");
		
		t1.start();
		t2.start();
	}
}

 

 例子程序04：脏读

/**
 * 对于对象的同步和异步方法，我们在设计自己的程序的时候，一定要考虑问题的整体，
 * 不然就会出现数据不一致的错误，很经典的错误就是脏读（dirty read）
 * getValue 和 setValue 是一个整体，所以都得加 synchronized
 * 业务整体需要使用synchronized，保持业务的原子性
 * @author 超轶绝尘
 *
 */
public class DirtyRead {
	private String name = "bjsxt";
	private String value = "123";
	
	
	public synchronized void setValue(String name, String value) {
		this.name = name;
		try {
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.value = value;
		System.out.println("setValue invoked, name ="  + this.name + " , value =" + this.value);
	}
	
	public synchronized void getValue() {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("getValue invoked, name ="  + this.name + " , value =" + this.value);
	}

	public static void main(String[] args) {
		final DirtyRead dr = new DirtyRead();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				dr.setValue("zhangsan", "456");
			}
		});
		
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				dr.getValue();
			}
		});
		
		t1.start();
		t2.start();

	}

}