Java线程和锁的简单使用用法

Java实现线程有以下两种方法：

1.实现Runnable接口

public class RunnableThreadExample implements Runnable {
	private int count = 0;

	@Override
	public void run() {
		System.out.println("RunnableThreadExample starting.");
		try {
			while (count < 5) {
				Thread.sleep(500);
				count++;
			}
		} catch (InterruptedException e) {
			System.out.println("RunnableThreadExample interrupt.");
		}
		System.out.println("RunnableThreadExample terminating.");
	}

	public static void main(String[] args) {
		RunnableThreadExample instance = new RunnableThreadExample();
		Thread thread = new Thread(instance);
		thread.start();
	}
}

2.继承Thread类

public class RunnableThreadExample extends Thread {
	private int count = 0;

	@Override
	public void run() {
		System.out.println("RunnableThreadExample starting.");
		try {
			while (count < 5) {
				Thread.sleep(500);
				count++;
			}
		} catch (InterruptedException e) {
			System.out.println("RunnableThreadExample interrupt.");
		}
		System.out.println("RunnableThreadExample terminating.");
	}

	public static void main(String[] args) {
		RunnableThreadExample instance = new RunnableThreadExample();
		instance.start();
	}
}

这两种方法中，建议使用第一种实现Runnable接口的方法，因为：

1）Java不支持多重继承，因此扩展Thread类就代表这个子类不能扩展其他类；

2）继承整个Thread类的开销过大。

Java中可以使用synchronized对共享资源的访问加以限制，使得这一块代码只能被一个线程所执行。

public class MyClass extends Thread{
	
	private String name;
	private MyObject myObj;
	
	public void run(){
		myObj.foo(name);
	}

	public MyClass(String name, MyObject myObj) {
		super();
		this.name = name;
		this.myObj = myObj;
	}

	public static void main(String[] args) {
		MyObject obj = new MyObject();
		MyClass thread1 = new MyClass("1", obj);
		MyClass thread2 = new MyClass("2", obj);
		thread1.start();
		thread2.start();
	}

	private static class MyObject{

		private synchronized void foo(String name) {
			System.out.println("Thread " + name + ".foo():starting");
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("Thread " + name + ".foo():ending");
		}
	}
}

执行结果如下：

Thread 1.foo():starting
Thread 1.foo():ending
Thread 2.foo():starting
Thread 2.foo():ending

可以看到，尽管Thread 1和Thread 2都启动了，但是Thread 2只能在Thread 1调用完foo()函数之后再调用。

若要实现更细粒度的控制，可以使用锁（Lock）。线程必须取得与资源关联的锁，才能访问共享资源。所以不管何时，做多只有一个线程能拿到锁，因此只有一个线程可以访问共享资源。

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

class MyThread extends Thread {

    private LockedATM atm;

    MyThread(LockedATM atm) {
        this.atm = atm;
    }

    @Override
    public void run() {
        System.out.println(this.getName() + ": after withdraw: " + atm.withdraw(this.getName(),200));
        System.out.println(this.getName() + ": after deposit: " + atm.deposit(this.getName(),100));
    }
}

public class LockedATM {
	private Lock lock;
	private int balance = 1000;

	public LockedATM() {
		this.lock = new ReentrantLock();
	}

	public int withdraw(String name, int value){
		lock.lock();
		System.out.println(name + ": withdraw starting...");
		int temp = balance;
		try {
			Thread.sleep(100);
			temp -= value;
			Thread.sleep(100);
			balance = temp;
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(name + ": withdraw ending...");
		lock.unlock();
		return balance;
	}
	
	public int deposit(String name, int value){
		lock.lock();
		System.out.println(name + ": deposit starting...");
		int temp = balance;
		try {
			Thread.sleep(100);
			temp += value;
			Thread.sleep(300);
			balance = temp;
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(name + ": deposit ending...");
		lock.unlock();
		return balance;
	}

	public static void main(String[] args) {
		LockedATM atm = new LockedATM();
		MyThread thread1 = new MyThread(atm);
		MyThread thread2 = new MyThread(atm);
		thread1.start();
		thread2.start();
	}

}

运行结果如下：

Thread-0: withdraw starting...
Thread-0: withdraw ending...
Thread-0: after withdraw: 800
Thread-1: withdraw starting...
Thread-1: withdraw ending...
Thread-1: after withdraw: 600
Thread-0: deposit starting...
Thread-0: deposit ending...
Thread-0: after deposit: 700
Thread-1: deposit starting...
Thread-1: deposit ending...
Thread-1: after deposit: 800

这个例子是模拟atm机存款（deposit）和取款（withdraw）。两个客户（Thread-0和Thread-1）都想进行先取200，再存100的操作。可以看到，withdraw和deposit方法中上了锁的部分，都只能被一个线程所执行。最后运行结果符合最终atm机里应该有的金额数。倘若，把上锁的几行代码注释掉，存款取款会发生混乱。