Java多线程并发笔记04

示例程序1.线程中改变lock 对象

/**
 * 锁对象改变的问题
 * 变了就没用了
 * */
public class ChangeLock {
	/**
	 * 锁对象变了，那么锁就没有用了，但若是锁对象的属性变了则是不影响锁的效用
	 */
	private String lock = "lock";
	
	/**
	 * 加同步锁的目的就是要保证原子性，即一个线程执行此方法体开始并结束后，另执另外一个开始结束
	 */
	private void methgod() {
		synchronized(lock) {
			System.out.println("当前线程"+Thread.currentThread().getName()+"开始");
			/**
			 * 未加这句话：（保持完整的原子性）
			 * 	当前线程t1开始（等待2000毫秒。。。）
				当前线程t1结束（等待100毫秒。。。）
				当前线程t2开始（等待2000毫秒。。。）
				当前线程t2结束
				
				加了这句话：t1,t2同时开始，等2000同时结束
				当前线程t1开始
				当前线程t2开始
				当前线程t1结束
				当前线程t2结束
			 */
			
			lock = "lock change";
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("当前线程"+Thread.currentThread().getName()+"结束");
		}
	}
	
	public static void main(String[] args) {
		final ChangeLock cl = new ChangeLock(); 
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				cl.methgod();
			}
		},"t1");
		
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				cl.methgod();
			}
		},"t2");
		
		
		t1.start();
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.start();
	}
	
}

示例程序2：死锁

public class DeadLock extends Thread{
	
	private String lock1 = "lock1";
	
	private String lock2 = "lock2";
	
	private String tag;
	
	public String getTag() {
		return tag;
	}

	public void setTag(String tag) {
		this.tag = tag;
	}

	@Override
	public void run() {
		if(tag.equals("a")){
			synchronized (lock1) {
				System.out.println("当前线程"+Thread.currentThread().getName()+"进入lock1执行");
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (lock2) {
					System.out.println("当前线程"+Thread.currentThread().getName()+"进入lock2执行");
				}
			}
		}
		if(tag.equals("b")){
			synchronized (lock2) {
				System.out.println("当前线程"+Thread.currentThread().getName()+"进入lock2执行");
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (lock1) {
					System.out.println("当前线程"+Thread.currentThread().getName()+"进入lock1执行");
				}
			}
		}
	}

	public static void main(String[] args) {
		DeadLock dl1 = new DeadLock();
		dl1.setTag("a");
		
		dl1.start();
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		DeadLock dl2 = new DeadLock();
		dl2.setTag("b");
		dl2.start();

	}

}

示例程序3 ：不改变lock对象，改变lock对象属性值，不会产生线程安全问题

public class ModifyLock {
	private String name;
	
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	
	public synchronized void changeAttri(String name, int age) {
		System.out.println("当前线程"+Thread.currentThread().getName()+"开始");
		this.setAge(age);
		this.setName(name);
		
		System.out.println("当前线程"+Thread.currentThread().getName()+"修改内容为："+ name+":"+age);
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("当前线程"+Thread.currentThread().getName()+"结束");
	}
	
	public static void main(String[] args) {
		final ModifyLock cl = new ModifyLock(); 
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				cl.changeAttri("aaa",2);
			}
		},"t1");
		
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				cl.changeAttri("bbb",3);
			}
		},"t2");
		
		
		t1.start();
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.start();
	}
	
	
}

 示例程序4：锁的种类

public class ObjectLock {
	public void method1(){
		synchronized (this) {//对象锁
			try {
				System.out.println("method1......");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public void method2(){
		synchronized (ObjectLock.class) {//类锁
			try {
				System.out.println("method2......");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	private Object lock = new Object();
	public void method3(){
		synchronized (lock) {//任何对象锁
			try {
				System.out.println("method3......");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	public static void main(String[] args) {
		final ObjectLock ol = new ObjectLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				ol.method1();
			}
		},"t1");
		
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				ol.method2();
			}
		},"t2");
		
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				ol.method3();
			}
		},"t3");
		
		
		t1.start();
		t2.start();
		t3.start();
	}
}

示例程序5：String对象锁

public class StringLock {
	public void method() {
		//如果锁是非new出来的，那么就是一个常量，则被独占while(true)死循环，，若是被new出来的，则2个对象
		/**
		 * 当前线程t2开始
			当前线程t1开始
			当前线程t1结束
			当前线程t2结束
		 */
//		synchronized (new String("字符串常量")) {
			
		/**
		 * 当前线程t1开始
			当前线程t1结束
			当前线程t1开始
			当前线程t1结束
		 */
		synchronized ("字符串常量") {
			try {
				while(true) {
					System.out.println("当前线程"+Thread.currentThread().getName()+"开始");
						Thread.sleep(2000);
					System.out.println("当前线程"+Thread.currentThread().getName()+"结束");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		final StringLock ol = new StringLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				ol.method();
			}
		},"t1");
		
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				ol.method();
			}
		},"t2");
		
		t1.start();
		t2.start();
	}
}