程序员面试金典（二）

本文主要是介绍程序员面试金典（二），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

线程与锁

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;@Overridepublic void run() {System.out.println("线程开始");try {while (count < 5) {Thread.sleep(2000);count ++ ;}} catch (InterruptedException e) {// TODO Auto-generated catch blocke.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 blocke.printStackTrace();}}}
}

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

public class ThreadExaple extends Thread{int count = 0;@Overridepublic 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 blockSystem.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 blocke.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 blocke.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 blocke.printStackTrace();}lock.unlock();return temp;}
}

3.死锁及死锁的预防

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

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

这篇关于程序员面试金典（二）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---