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

谁借莪１个温暖的怀抱￠ 2022-06-12 09:13 89阅读 0赞

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机里应该有的金额数。倘若，把上锁的几行代码注释掉，存款取款会发生混乱。