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
若要实现更细粒度的控制,可以使用锁(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机里应该有的金额数。倘若,把上锁的几行代码注释掉,存款取款会发生混乱。