程序员面试金典（二）

线程与锁

1.java线程

在java中，每个线程的创建和控制都是由 java.lang.Thread 类的独特对象对象实现。一个独立的应用运行时，会自动创建一个用户线程，执行 main() 方法，这个线程叫主线程。在java中，实现线程有两种方式：

• 通过实现 java.lang.Runnable 接口；
• 通过扩展 java.lang.Thread 类。

（1）实现Runnable接口
Runnable接口结构非常简单：

public interface Runnable{
    void run();
}

要用这个接口创建和使用线程，看一个具体的例子;

package com.czl.thread;

public class RunnableExample implements Runnable{

    public int count = 0;

    @Override
    public void run() {
        System.out.println("线程开始");
        try {
            while (count < 5) {
                Thread.sleep(2000);
                count ++ ;
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("线程中断");
        }
        System.out.println("线程终结"); 
    }

}

package com.czl.thread;
public class TestRunnable {
    public static void main(String[] args) {
        RunnableExample instance = new RunnableExample();
        Thread thread = new Thread(instance);
        thread.start();//线程开始

        while (instance.count != 5) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

（2）扩展Thread类
使用这种方式，基本就意味着要重写 run() 方法并且在子类的构造函数里，还需要显式调用这个县城的构造函数。

public class ThreadExaple extends Thread{
    int count = 0;
    @Override
    public void run() {
        super.run();
        System.out.println("Thread starting");
        try {
            while (count < 5) {
                Thread.sleep(500);
                System.out.println("in thread,count is :" + count);
                count ++;
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            System.out.println("thread interrupted.");
        }
        System.out.println("thread terminating.");
    }

}

public static void main(String[] args) {
        ThreadExaple threadExaple = new ThreadExaple();
        threadExaple.start();

        while (threadExaple.count != 5) {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

Tips:
在创建线程时，相比扩展Thread类，实现Runnable接口可能更优，有两个理由：

• Java不支持多重继承。因此，扩展Thread类也就代表这个子类不能扩展其他类。而实现Runnble接口的类还能扩展另一个类。
• 类可能只要求执行即可，因此，继承整个Thread的开销过大。

2.同步和锁

给定一个进程内的所有线程，都共享同一存储空间，这样有利有弊。这些线程可以共享数据，非常有用。不过，在两个线程同时修改同一资源时，会出现问题。Java提供了同步机制，以控制对共享资源的访问。
关键字 synchronized 和 lock 构成了代码同步执行的基础。

• 同步方法
  最常见的就是使用 synchronized 关键字实现同步功能。该关键字可以用在方法和代码块上，限制多个线程，使之不能同时执行同一个对象的代码。

public class MyTest extends Thread{
    public void run(){

    }
}

public class MyObject{
    public static synchronized void fun(){

    }
    public static synchronized void foo(){

    }
}

• 同步块

代码块也可以实现同步化，其实现原理跟同步方法相似。

public class MyTest extends Thread{
    public void run(){

    }
}
public class MyObject{
    public void fun(String name){
        synchronized(this){

        }
    }
}

• 锁
  若要实现更细致的控制，使用锁（lock），用于对共享资源的同步访问，方法是用锁将共享资源关联在一起，线程必须先取得与资源关联的锁，才能访问共享资源。不管在任何时间点，最多只能有一个线程拿到锁，因此只有一个线程可以访问共享资源。
  锁的常见用法，从多个地方访问同一资源时，同一时刻只有一个线程可以访问。

public class TestLock {
    private Lock lock;
    private int balance = 100;
    public TestLock(){
        lock = new ReentrantLock();
    }

    public int withdraw(int value){
        lock.lock();
        int temp = balance;
        try {
            Thread.sleep(200);
            temp = temp - value;
            Thread.sleep(200);
            balance = temp;
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        lock.unlock();
        return temp;
    }

    public int deposit(int value){
        lock.lock();
        int temp = balance;

        try {
            Thread.sleep(200);
            temp = temp + value;
            Thread.sleep(500);
            balance = temp;
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        lock.unlock();
        return temp;
    }
}

3.死锁及死锁的预防

死锁（deadlock）是这样一种情况：第一个线程在等待第二个线程持有的某个对象锁，而第二个线程又在等待第一个线程持有的对象锁（或是由两个以上线程形成的类似情形）。由于每个线程都在等待其他线程释放锁，以致每个线程都会一直这么等下去。于是，这些线程就陷入了死锁状态。
死锁的出现必须同时满足以下四个条件：
（1）互斥：某一时刻只有一个线程能访问某一资源。（或者，更准确的说，对某一资源的访问有限制。若有资源限制，也有可能出现死锁）
（2）持有并等待：已持有某一资源的进程不必释放当前拥有的资源，就能要求更多的资源。
（3）没有抢占：一个进程不能强制另一个进程释放资源。
（4）循环等待：两个或两个以上的进程形成循环链，每个进程都在等待循环链中另一进程持有的资源。

若要预防死锁，只需避免上述任一条件，比较困难。比如，想要避免条件1就很困难，因为许多资源同一时刻只能被一个进程使用（如打印机）。大部分预防死锁的算法都把重心放在循环等待上。