面试题目——《CC150》线程与锁

package cc150.thread_lock;

public class RunnableThreadExample implements Runnable{

	public int count = 0;

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		RunnableThreadExample instance = new RunnableThreadExample();
		Thread thread = new Thread(instance);
		thread.start();
		//等到上面的线程数到5
		while(instance.count != 5){
			try{
				Thread.sleep(250);
				System.out.println("等待");
			}catch(InterruptedException exc){
				exc.printStackTrace();
			}
		}
	}

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		System.out.println("RunnableThread开始");
		try{
			while(count < 5){
				Thread.sleep(500);
				count++;
			}
		}catch(InterruptedException exc){
			System.out.println("RunnableThread中断");
		}
		System.out.println("RunnableThread终止");
	}

}

package cc150.thread_lock;

public class ThreadExample{

	public static void main(String[] args){
		// TODO 自动生成的方法存根
		ThreadExample th = new ThreadExample();
		threadExample instance = th.new threadExample();
		instance.start();
		//等到上面的线程数到5
		while(instance.count != 5){
			try{
				Thread.sleep(250);
				System.out.println("等待");
			}catch(InterruptedException exc){
				exc.printStackTrace();
			}
		}
	}

	public class threadExample extends Thread{
		int count = 0;
		public void run() {
			// TODO 自动生成的方法存根
			System.out.println("Thread开始");
			try{
				while(count < 5){
					Thread.sleep(500);
					System.out.println("在线程中，count是"+count);
					count++;
				}
			}catch(InterruptedException exc){
				System.out.println("RunnableThread中断");
			}
			System.out.println("RunnableThread终止");
		}
	}
}

package cc150.thread_lock;

class MyObject{
	public synchronized void foo(String name){		//加上synchronized关键字，给foo提供同步
		try{
			System.out.println("线程"+name+".foo()开始");
			Thread.sleep(3000);
			System.out.println("线程"+name+".foo()结束");
		}catch(InterruptedException exc){
			System.out.println("线程"+name+"中断");
		}
	}
}

public class MyClass extends Thread{		//不同的线程，来调用上面的foo

	private String name;
	private MyObject myObj;

	public MyClass(MyObject obj,String n){
		name = n;
		myObj = obj;
	}

	public void run(){
		myObj.foo(name);
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		MyObject obj1 = new MyObject();
//		MyObject obj2 = new MyObject();
//		MyClass thread1 = new MyClass(obj1,"1");
//		MyClass thread2 = new MyClass(obj2,"2");
//		thread1.start();
//		thread2.start();

		//相同的obj引用，只能一个线程可以调用foo，另一个线程必须等待
		MyObject obj = new MyObject();
		MyClass thread11 = new MyClass(obj,"1");
		MyClass thread22 = new MyClass(obj,"2");
		thread11.start();
		thread22.start();
	}

}

package cc150.thread_lock;

class MyObject{
	public static synchronized void foo(String name){		//加上synchronized关键字，给foo提供同步
		try{
			System.out.println("线程"+name+".foo()开始");
			Thread.sleep(3000);
			System.out.println("线程"+name+".foo()结束");
		}catch(InterruptedException exc){
			System.out.println("线程"+name+"中断");
		}
	}

	public static synchronized void bar(String name){		//加上synchronized关键字，给bar提供同步
		try{
			System.out.println("线程"+name+".bar()开始");
			Thread.sleep(3000);
			System.out.println("线程"+name+".bar()结束");
		}catch(InterruptedException exc){
			System.out.println("线程"+name+"中断");
		}
	}
}

public class MyClass extends Thread{		//不同的线程，来调用上面的foo

	private String name;
	private MyObject myObj;

	public MyClass(MyObject obj,String n){
		name = n;
		myObj = obj;
	}

	public void run(){
		//myObj.foo(name);
		if(name.equals("1"))
			MyObject.foo(name);
		else if(name.equals("2"))
			MyObject.bar(name);
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		MyObject obj1 = new MyObject();
//		MyObject obj2 = new MyObject();
//		MyClass thread1 = new MyClass(obj1,"1");
//		MyClass thread2 = new MyClass(obj2,"2");
//		thread1.start();
//		thread2.start();

		//相同的obj引用，只能一个线程可以调用foo，另一个线程必须等待
		MyObject obj = new MyObject();
		MyClass thread11 = new MyClass(obj,"1");
		MyClass thread22 = new MyClass(obj,"2");
		thread11.start();
		thread22.start();
	}

}

package cc150.thread_lock;

class MyObject2{
	public synchronized void foo(String name){		//加上synchronized块，给foo提供同步
		synchronized(this){
			try{
				System.out.println("线程"+name+".foo()开始");
				Thread.sleep(3000);
				System.out.println("线程"+name+".foo()结束");
			}catch(InterruptedException exc){
				System.out.println("线程"+name+"中断");
			}
		}
	}

}

public class MyClass2 extends Thread{		//不同的线程，来调用上面的foo

	private String name;
	private MyObject2 myObj;

	public MyClass2(MyObject2 obj,String n){
		name = n;
		myObj = obj;
	}

	public void run(){
		myObj.foo(name);
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		MyObject obj1 = new MyObject();
//		MyObject obj2 = new MyObject();
//		MyClass thread1 = new MyClass(obj1,"1");
//		MyClass thread2 = new MyClass(obj2,"2");
//		thread1.start();
//		thread2.start();

		//相同的obj引用，只能一个线程可以调用foo，另一个线程必须等待
		MyObject2 obj = new MyObject2();
		MyClass2 thread11 = new MyClass2(obj,"1");
		MyClass2 thread22 = new MyClass2(obj,"2");
		thread11.start();
		thread22.start();
	}

}

package cc150.thread_lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class MyObj {

	private Lock lock;
	private int balance = 100;	//剩余

	public MyObj(){						//构造函数
		lock = new ReentrantLock();		//可重入锁
	}

	public int withdraw(int value){	//取款
		lock.lock();
		int temp = balance;
		try{
			Thread.sleep(100);
			temp = temp-value;
			Thread.sleep(100);
			balance = temp;
		}catch(InterruptedException e){

		}
		lock.unlock();
		return temp;
	}

	public int deposit(int value){	//存款
		lock.lock();
		int temp = balance;
		try{
			Thread.sleep(100);
			temp = temp+value;
			Thread.sleep(100);
			balance = temp;
		}catch(InterruptedException e){

		}
		lock.unlock();
		return temp;
	}
}

public class LockedATM extends Thread{

	private int value;
	private MyObj myObj;
	private String str;

	public LockedATM(MyObj obj,String  s,int v){
		value = v;
		myObj = obj;
		str = s;
	}

	public void run(){
		if(str.equals("withdraw"))
			System.out.println(myObj.withdraw(value));
		else if(str.equals("deposit"))
			System.out.println(myObj.deposit(value));
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyObj obj1 = new MyObj();
		MyObj obj2 = new MyObj();
		LockedATM thread1 = new LockedATM(obj1,"withdraw",50); 	//两个线程执行的顺序不一定
		LockedATM thread2 = new LockedATM(obj2,"deposit",50);		//可能先存款，也可能先取款
		thread1.start();
		thread2.start();
	}
}