Java多線程和并發(fā)面試題（附答案）11~16題

11.同一個(gè)類(lèi)中的2個(gè)方法都加了同步鎖，多個(gè)線程能同時(shí)訪問(wèn)同一個(gè)類(lèi)中的這兩個(gè)方法嗎？

這個(gè)問(wèn)題需要考慮到Lock與synchronized兩種實(shí)現(xiàn)鎖的不同情形。因?yàn)檫@種情況下使用Lock和synchronized會(huì)有截然不同的結(jié)果。Lock可以讓等待鎖的線程響應(yīng)中斷，Lock獲取鎖，之后需要釋放鎖。如下代碼，多個(gè)線程不可訪問(wèn)同一個(gè)類(lèi)中的2個(gè)加了Lock鎖的方法。

package com.bjpowernode;

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

public class qq {

    private int count = 0;
    private Lock lock = new ReentrantLock();//設(shè)置 lock 鎖
    //方法 1
    public Runnable run1 = new Runnable() {
        public void run() {
            lock.lock(); //加鎖
            while (count < 1000) {
                try {
                    //打印是否執(zhí)行該方法
                    System.out.println(Thread.currentThread().getName() + " run1: " + count++);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
      lock.unlock();
    }

    //方法 2
    public Runnable run2 = new Runnable() {
        public void run() {
            lock.lock();
            while (count < 1000) {
                try {
                    System.out.println(Thread.currentThread().getName() +
                            " run2: " + count++);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            lock.unlock();
        }
    };

    public static void main(String[] args) throws InterruptedException {
        qq t = new qq();    //創(chuàng)建一個(gè)對(duì)象
        new Thread(t.run1).start();//獲取該對(duì)象的方法 1

        new Thread(t.run2).start();//獲取該對(duì)象的方法 2
    }
}

結(jié)果是：

Thread-0 run1: 0

Thread-0 run1: 1

Thread-0 run1: 2

Thread-0 run1: 3

Thread-0 run1: 4

Thread-0 run1: 5

Thread-0 run1: 6

........

而synchronized卻不行，使用synchronized時(shí)，當(dāng)我們?cè)L問(wèn)同一個(gè)類(lèi)對(duì)象的時(shí)候，是同一把鎖，所以可以訪問(wèn)該對(duì)象的其他synchronized方法。代碼如下：

package com.bjpowernode;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class qq {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    public Runnable run1 = new Runnable() {
        public void run() {
            synchronized (this) { //設(shè)置關(guān)鍵字 synchronized，以當(dāng)前類(lèi)為鎖
                while (count < 1000) {
                    try {
                        //打印是否執(zhí)行該方法
                        System.out.println(Thread.currentThread().getName() + " run1: " + count++);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };
    public Runnable run2 = new Runnable() {
        public void run() {
            synchronized (this) {
                while (count < 1000) {
                    try {
                        System.out.println(Thread.currentThread().getName()
                                + " run2: " + count++);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };

    public static void main(String[] args) throws InterruptedException {
        qq t = new qq(); //創(chuàng)建一個(gè)對(duì)象
        new Thread(t.run1).start(); //獲取該對(duì)象的方法 1
        new Thread(t.run2).start(); //獲取該對(duì)象的方法 2
    }
}

結(jié)果為：

Thread-1 run2: 0

Thread-1 run2: 1

Thread-1 run2: 2

Thread-0 run1: 0

Thread-0 run1: 4

Thread-0 run1: 5

Thread-0 run1: 6

......

12.什么情況下導(dǎo)致線程死鎖，遇到線程死鎖該怎么解決？

● 死鎖的定義：所謂死鎖是指多個(gè)線程因競(jìng)爭(zhēng)資源而造成的一種僵局（互相等待），若無(wú)外力作用，這些進(jìn)程都將無(wú)法向前推進(jìn)。

● 死鎖產(chǎn)生的必要條件：

● 互斥條件：線程要求對(duì)所分配的資源（如打印機(jī)）進(jìn)行排他性控制，即在一段時(shí)間內(nèi)某資源僅為一個(gè)線程所占有。此時(shí)若有其他線程請(qǐng)求該資源，則請(qǐng)求線程只能等待。

● 不剝奪條件：線程所獲得的資源在未使用完畢之前，不能被其他線程強(qiáng)行奪走，即只能由獲得該資源的線程自己來(lái)釋放（只能是主動(dòng)釋放)。

● 請(qǐng)求和保持條件：線程已經(jīng)保持了至少一個(gè)資源，但又提出了新的資源請(qǐng)求，而該資源已被其他線程占有，此時(shí)請(qǐng)求進(jìn)程被阻塞，但對(duì)自己已獲得的資源保持不放。

● 循環(huán)等待條件：存在一種線程資源的循環(huán)等待鏈，鏈中每一個(gè)線程已獲得的資源同時(shí)被鏈中下一個(gè)線程所請(qǐng)求。即存在一個(gè)處于等待狀態(tài)的線程集合{Pl，P2，...，pn}，其中Pi等待的資源被P(i+1)占有（i=0，1，...，n-1)，Pn等待的資源被P0占有，如圖2-15所示。

產(chǎn)生死鎖的一個(gè)例子：

package com.bjpowernode;

/**
 * 一個(gè)簡(jiǎn)單的死鎖類(lèi)
 * 當(dāng) DeadLock 類(lèi)的對(duì)象 flag==1 時(shí)（td1），先鎖定 o1，睡眠 500 毫秒
 * 而 td1 在睡眠的時(shí)候另一個(gè) flag==0 的對(duì)象（td2）線程啟動(dòng)，先鎖定 o2，睡眠 500 毫秒
 * <p>
 * <p>
 * <p>
 * td1 睡眠結(jié)束后需要鎖定 o2 才能繼續(xù)執(zhí)行，而此時(shí) o2 已被 td2 鎖定；
 * td2 睡眠結(jié)束后需要鎖定 o1 才能繼續(xù)執(zhí)行，而此時(shí) o1 已被 td1 鎖定；
 * td1、td2 相互等待，都需要得到對(duì)方鎖定的資源才能繼續(xù)執(zhí)行，從而死鎖。
 */
public class DeadLock implements Runnable {
    public int flag = 1;
    //靜態(tài)對(duì)象是類(lèi)的所有對(duì)象共享的
    private static Object o1 = new Object(), o2 = new Object();

    public void run() {
        System.out.println("flag=" + flag);
        if (flag == 1) {
            synchronized (o1) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (o2) {
                    System.out.println("1");
                }
            }
        }
        if (flag == 0) {
            synchronized (o2) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (o1) {
                    System.out.println("0");
                }
            }
        }
    }
    public static void main(String[] args) {
        DeadLock td1 = new DeadLock();
        DeadLock td2 = new DeadLock();
        td1.flag = 1;
        td2.flag = 0;
        //td1，td2 都處于可執(zhí)行狀態(tài)，但 JVM 線程調(diào)度先執(zhí)行哪個(gè)線程是不確定的。
        //td2 的 run()可能在 td1 的 run()之前運(yùn)行
        new Thread(td1).start();
        new Thread(td2).start();
    }
}

● 如何避免死鎖？

在有些情況下死鎖是可以避免的。兩種用于避免死鎖的技術(shù)：

● 加鎖順序（線程按照一定的順序加鎖）

package bjpowernode.com;

public class DeadLock {
    public int flag = 1;
    //靜態(tài)對(duì)象是類(lèi)的所有對(duì)象共享的
    private static Object o1 = new Object(), o2 = new Object();

    public void money(int flag) {
        this.flag = flag;
        if (flag == 1) {
            synchronized (o1) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (o2) {
                    System.out.println("當(dāng)前的線程是" +
                            Thread.currentThread().getName() + " " + "flag 的值" + "1");
                }
            }
        }
        if (flag == 0) {
            synchronized (o2) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (o1) {
                    System.out.println("當(dāng)前的線程是" +
                            Thread.currentThread().getName() + " " + "flag 的值" + "0");
                }
            }
        }
    }

    public static void main(String[] args) {
        final DeadLock td1 = new DeadLock();
        final DeadLock td2 = new DeadLock();
        td1.flag = 1;
        td2.flag = 0;
        //td1，td2 都處于可執(zhí)行狀態(tài)，但 JVM 線程調(diào)度先執(zhí)行哪個(gè)線程是不確定的。
        //td2 的 run()可能在 td1 的 run()之前運(yùn)行
        final Thread t1 = new Thread(new Runnable() {
            public void run() {
                td1.flag = 1;
                td1.money(1);
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                // TODO Auto-generated method stub
                try {
                    //讓 t2 等待 t1 執(zhí)行完
                    t1.join();//核心代碼，讓 t1 執(zhí)行完后 t2 才會(huì)執(zhí)行
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                td2.flag = 0;
                td1.money(0);
            }
        });
        t2.start();
    }
}

結(jié)果：

當(dāng)前的線程是 Thread-0 flag 的值 1

當(dāng)前的線程是 Thread-1 flag 的值 0

● 加鎖時(shí)限（線程嘗試獲取鎖的時(shí)候加上一定的時(shí)限，超過(guò)時(shí)限則放棄對(duì)該鎖的請(qǐng)求，并釋放自己占有的鎖）。

package com.bjpowernode;

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

public class DeadLock {

    public int flag = 1;
    //靜態(tài)對(duì)象是類(lèi)的所有對(duì)象共享的
    private static Object o1 = new Object(), o2 = new Object();

    public void money(int flag) throws InterruptedException {
        this.flag = flag;
        if (flag == 1) {
            synchronized (o1) {
                Thread.sleep(500);
                synchronized (o2) {
                    System.out.println("當(dāng)前的線程是" +
                            Thread.currentThread().getName() + " " + "flag 的值" + "1");
                }
            }
        }
        if (flag == 0) {
            synchronized (o2) {
                Thread.sleep(500);
                synchronized (o1) {
                    System.out.println("當(dāng)前的線程是" +
                            Thread.currentThread().getName() + " " + "flag 的值" + "0");
                }
            }
        }
    }

    public static void main(String[] args) {
        final Lock lock = new ReentrantLock();
        final DeadLock td1 = new DeadLock();
        final DeadLock td2 = new DeadLock();
        td1.flag = 1;
        td2.flag = 0;
        //td1,td2 都處于可執(zhí)行狀態(tài),但 JVM 線程調(diào)度先執(zhí)行哪個(gè)線程是不確定的。
        //td2 的 run()可能在 td1 的 run()之前運(yùn)行39．
        final Thread t1 = new Thread(new Runnable() {
            public void run() {
                // TODO Auto-generated method stub
                String tName = Thread.currentThread().getName();

                td1.flag = 1;
                try {
                    //獲取不到鎖,就等 5 秒,如果 5 秒后還是獲取不到就返回 false
                    if (lock.tryLock(5000, TimeUnit.MILLISECONDS)) {

                        System.out.println(tName + "獲取到鎖！");
                    } else {
                        System.out.println(tName + "獲取不到鎖！");
                        return;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

                try {
                    td1.money(1);
                } catch (Exception e) {
                    System.out.println(tName + "出錯(cuò)了！??！");
                } finally {
                    System.out.println("當(dāng)前的線程是" + Thread.currentThread().getName() + "釋放鎖！！");
                    lock.unlock();
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                String tName = Thread.currentThread().getName();
                // TODO Auto-generated method stub
                td1.flag = 1;
                try {
                    //獲取不到鎖,就等 5 秒,如果 5 秒后還是獲取不到就返回 false
                    if (lock.tryLock(5000, TimeUnit.MILLISECONDS)) {
                        System.out.println(tName + "獲取到鎖！");
                    } else {
                        System.out.println(tName + "獲取不到鎖！");
                        return;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                try {
                    td2.money(0);
                } catch (Exception e) {
                    System.out.println(tName + "出錯(cuò)了?。。?);
                } finally {
                    System.out.println("當(dāng)前的線程是" + Thread.currentThread().getName() + "釋放鎖??！");
                    lock.unlock();
                }
            }
        });
        t2.start();
    }
}

打印結(jié)果：

Thread-0獲取到鎖！

當(dāng)前的線程是Thread-0 flag的值1

當(dāng)前的線程是Thread-0釋放鎖！！

Thread-1獲取到鎖！

當(dāng)前的線程是Thread-1 flag的值0

當(dāng)前的線程是Thread-1釋放鎖??！

13.Java 中多線程間的通信怎么實(shí)現(xiàn)?

線程通信的方式：

● 共享變量

線程間通信可以通過(guò)發(fā)送信號(hào)，發(fā)送信號(hào)的一個(gè)簡(jiǎn)單方式是在共享對(duì)象的變量里設(shè)置信號(hào)值。線程A在一個(gè)同步塊里設(shè)置boolean型成員變量hasDataToProcess為true，線程B也在同步塊里讀取hasDataToProcess這個(gè)成員變量。這個(gè)簡(jiǎn)單的例子使用了一個(gè)持有信號(hào)的對(duì)象，并提供了set和get方法：

package com.bjpowernode;

public class MySignal {
    //共享的變量
    private boolean hasDataToProcess = false;

    //取值
    public boolean getHasDataToProcess() {
        return hasDataToProcess;
    }
    //存值
    public void setHasDataToProcess(boolean hasDataToProcess) {
        this.hasDataToProcess = hasDataToProcess;
    }

    public static void main(String[] args) {
        //同一個(gè)對(duì)象
        final MySignal my = new MySignal();
        //線程 1 設(shè)置 hasDataToProcess 值為 true
        final Thread t1 = new Thread(new Runnable() {
            public void run() {
                my.setHasDataToProcess(true);
            }
        });
        t1.start();
        //線程 2 取這個(gè)值 hasDataToProcess
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                try {
                    //等待線程 1 完成然后取值
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                my.getHasDataToProcess();
                System.out.println("t1 改變以后的值：" + my.isHasDataToProcess());
            }
        });
        t2.start();
    }
}

結(jié)果：

t1 改變以后的值：true

● wait/notify機(jī)制

以資源為例，生產(chǎn)者生產(chǎn)一個(gè)資源，通知消費(fèi)者就消費(fèi)掉一個(gè)資源，生產(chǎn)者繼續(xù)生產(chǎn)資源，消費(fèi)者消費(fèi)資源，以此循環(huán)。代碼如下：

package com.bjpowernode;

//資源類(lèi)
class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;

    public synchronized void set(String name) {
        //生產(chǎn)資源
        while (flag) {
            try {
                //線程等待。消費(fèi)者消費(fèi)資源
                wait();
            } catch (Exception e) {
            }
        }
        this.name = name + "---" + count++;
        System.out.println(Thread.currentThread().getName() + "...生產(chǎn)者..." + this.name);
        flag = true;
        //喚醒等待中的消費(fèi)者
        this.notifyAll();
    }

    public synchronized void out() {
        //消費(fèi)資源
        while (!flag) {
            //線程等待，生產(chǎn)者生產(chǎn)資源
            try {
                wait();
            } catch (Exception e) {
            }
        }
        System.out.println(Thread.currentThread().getName() + "...消費(fèi)者..." + this.name);
        flag = false;
        //喚醒生產(chǎn)者，生產(chǎn)資源
        this.notifyAll();
    }
}

//生產(chǎn)者
class Producer implements Runnable {
    private Resource res;

    Producer(Resource res) {
        this.res = res;
    }

    //生產(chǎn)者生產(chǎn)資源
    public void run() {
        while (true) {
            res.set("商品");
        }
    }
}

//消費(fèi)者消費(fèi)資源
class Consumer implements Runnable {
    private Resource res;

    Consumer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            res.out();
        }
    }
}

public class ProducerConsumerDemo {
    public static void main(String[] args) {
        Resource r = new Resource();
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        t1.start();
        t2.start();
    }
}

14.線程和進(jìn)程的區(qū)別?

● 進(jìn)程：具有一定獨(dú)立功能的程序關(guān)于某個(gè)數(shù)據(jù)集合上的一次運(yùn)行活動(dòng)，是操作系統(tǒng)進(jìn)行資源分配和調(diào)度的一個(gè)獨(dú)立單位。

● 線程：是進(jìn)程的一個(gè)實(shí)體，是cpu調(diào)度和分派的基本單位，是比進(jìn)程更小的可以獨(dú)立運(yùn)行的基本單位。

特點(diǎn)：線程的劃分尺度小于進(jìn)程，這使多線程程序擁有高并發(fā)性，進(jìn)程在運(yùn)行時(shí)各自?xún)?nèi)存單元相互獨(dú)立，線程之間內(nèi)存共享，這使多線程編程可以擁有更好的性能和用戶(hù)體驗(yàn)。

注意：多線程編程對(duì)于其它程序是不友好的，占據(jù)大量cpu資源。

15.請(qǐng)說(shuō)出同步線程及線程調(diào)度相關(guān)的方法？

wait()：使一個(gè)線程處于等待（阻塞）狀態(tài)，并且釋放所持有的對(duì)象的鎖；

sleep()：使一個(gè)正在運(yùn)行的線程處于睡眠狀態(tài)，是一個(gè)靜態(tài)方法，調(diào)用此方法要處理InterruptedException異常；

notify()：?jiǎn)拘岩粋€(gè)處于等待狀態(tài)的線程，當(dāng)然在調(diào)用此方法的時(shí)候，并不能確切的喚醒某一個(gè)等待狀態(tài)的線程，而是由JVM確定喚醒哪個(gè)線程，而且與優(yōu)先級(jí)無(wú)關(guān)；

notityAll()：?jiǎn)拘阉刑幱诘却隣顟B(tài)的線程，該方法并不是將對(duì)象的鎖給所有線程，而是讓它們競(jìng)爭(zhēng)，只有獲得鎖的線程才能進(jìn)入就緒狀態(tài)；

注意：java 5通過(guò)Lock接口提供了顯示的鎖機(jī)制，Lock接口中定義了加鎖（lock()方法）和解鎖（unLock()方法），增強(qiáng)了多線程編程的靈活性及對(duì)線程的協(xié)調(diào)。

16.啟動(dòng)一個(gè)線程是調(diào)用run()方法還是start()方法？

啟動(dòng)一個(gè)線程是調(diào)用 start()方法，使線程所代表的虛擬處理機(jī)處于可運(yùn)行狀態(tài)，這意味著它可以由 JVM 調(diào)度并執(zhí)行，這并不意味著線程就會(huì)立即運(yùn)行。

run()方法是線程啟動(dòng)后要進(jìn)行回調(diào)（callback）的方法。