黄色网址大全免费-黄色网址你懂得-黄色网址你懂的-黄色网址有那些-免费超爽视频-免费大片黄国产在线观看

第一部分 Java基礎
第二部分 Java進階

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

11.同一個類中的2個方法都加了同步鎖，多個線程能同時訪問同一個類中的這兩個方法嗎？

這個問題需要考慮到Lock與synchronized兩種實現鎖的不同情形。因為這種情況下使用Lock和synchronized會有截然不同的結果。Lock可以讓等待鎖的線程響應中斷，Lock獲取鎖，之后需要釋放鎖。如下代碼，多個線程不可訪問同一個類中的2個加了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();//設置 lock 鎖
    //方法 1
    public Runnable run1 = new Runnable() {
        public void run() {
            lock.lock(); //加鎖
            while (count < 1000) {
                try {
                    //打印是否執行該方法
                    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();    //創建一個對象
        new Thread(t.run1).start();//獲取該對象的方法 1

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

結果是：

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時，當我們訪問同一個類對象的時候，是同一把鎖，所以可以訪問該對象的其他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) { //設置關鍵字 synchronized，以當前類為鎖
                while (count < 1000) {
                    try {
                        //打印是否執行該方法
                        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(); //創建一個對象
        new Thread(t.run1).start(); //獲取該對象的方法 1
        new Thread(t.run2).start(); //獲取該對象的方法 2
    }
}

結果為：

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.什么情況下導致線程死鎖，遇到線程死鎖該怎么解決？

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

● 死鎖產生的必要條件：

● 互斥條件：線程要求對所分配的資源（如打印機）進行排他性控制，即在一段時間內某資源僅為一個線程所占有。此時若有其他線程請求該資源，則請求線程只能等待。

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

● 請求和保持條件：線程已經保持了至少一個資源，但又提出了新的資源請求，而該資源已被其他線程占有，此時請求進程被阻塞，但對自己已獲得的資源保持不放。

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

產生死鎖的一個例子：

package com.bjpowernode;

/**
 * 一個簡單的死鎖類
 * 當 DeadLock 類的對象 flag==1 時（td1），先鎖定 o1，睡眠 500 毫秒
 * 而 td1 在睡眠的時候另一個 flag==0 的對象（td2）線程啟動，先鎖定 o2，睡眠 500 毫秒
 * <p>
 * <p>
 * <p>
 * td1 睡眠結束后需要鎖定 o2 才能繼續執行，而此時 o2 已被 td2 鎖定；
 * td2 睡眠結束后需要鎖定 o1 才能繼續執行，而此時 o1 已被 td1 鎖定；
 * td1、td2 相互等待，都需要得到對方鎖定的資源才能繼續執行，從而死鎖。
 */
public class DeadLock implements Runnable {
    public int flag = 1;
    //靜態對象是類的所有對象共享的
    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 都處于可執行狀態，但 JVM 線程調度先執行哪個線程是不確定的。
        //td2 的 run()可能在 td1 的 run()之前運行
        new Thread(td1).start();
        new Thread(td2).start();
    }
}

● 如何避免死鎖？

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

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

package bjpowernode.com;

public class DeadLock {
    public int flag = 1;
    //靜態對象是類的所有對象共享的
    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("當前的線程是" +
                            Thread.currentThread().getName() + " " + "flag 的值" + "1");
                }
            }
        }
        if (flag == 0) {
            synchronized (o2) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (o1) {
                    System.out.println("當前的線程是" +
                            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 都處于可執行狀態，但 JVM 線程調度先執行哪個線程是不確定的。
        //td2 的 run()可能在 td1 的 run()之前運行
        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 執行完
                    t1.join();//核心代碼，讓 t1 執行完后 t2 才會執行
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                td2.flag = 0;
                td1.money(0);
            }
        });
        t2.start();
    }
}

結果：

當前的線程是 Thread-0 flag 的值 1

當前的線程是 Thread-1 flag 的值 0

● 加鎖時限（線程嘗試獲取鎖的時候加上一定的時限，超過時限則放棄對該鎖的請求，并釋放自己占有的鎖）。

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;
    //靜態對象是類的所有對象共享的
    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("當前的線程是" +
                            Thread.currentThread().getName() + " " + "flag 的值" + "1");
                }
            }
        }
        if (flag == 0) {
            synchronized (o2) {
                Thread.sleep(500);
                synchronized (o1) {
                    System.out.println("當前的線程是" +
                            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 都處于可執行狀態,但 JVM 線程調度先執行哪個線程是不確定的。
        //td2 的 run()可能在 td1 的 run()之前運行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 + "出錯了！??！");
                } finally {
                    System.out.println("當前的線程是" + 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 + "出錯了！??！");
                } finally {
                    System.out.println("當前的線程是" + Thread.currentThread().getName() + "釋放鎖！！");
                    lock.unlock();
                }
            }
        });
        t2.start();
    }
}

打印結果：

Thread-0獲取到鎖！

當前的線程是Thread-0 flag的值1

當前的線程是Thread-0釋放鎖??！

Thread-1獲取到鎖！

當前的線程是Thread-1 flag的值0

當前的線程是Thread-1釋放鎖??！

13.Java 中多線程間的通信怎么實現?

線程通信的方式：

● 共享變量

線程間通信可以通過發送信號，發送信號的一個簡單方式是在共享對象的變量里設置信號值。線程A在一個同步塊里設置boolean型成員變量hasDataToProcess為true，線程B也在同步塊里讀取hasDataToProcess這個成員變量。這個簡單的例子使用了一個持有信號的對象，并提供了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) {
        //同一個對象
        final MySignal my = new MySignal();
        //線程 1 設置 hasDataToProcess 值為 true
        final Thread t1 = new Thread(new Runnable() {
            public void run() {
                my.setHasDataToProcess(true);
            }
        });
        t1.start();
        //線程 2 取這個值 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();
    }
}

結果：

t1 改變以后的值：true

● wait/notify機制

以資源為例，生產者生產一個資源，通知消費者就消費掉一個資源，生產者繼續生產資源，消費者消費資源，以此循環。代碼如下：

package com.bjpowernode;

//資源類
class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;

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

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

//生產者
class Producer implements Runnable {
    private Resource res;

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

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

//消費者消費資源
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.線程和進程的區別?

● 進程：具有一定獨立功能的程序關于某個數據集合上的一次運行活動，是操作系統進行資源分配和調度的一個獨立單位。

● 線程：是進程的一個實體，是cpu調度和分派的基本單位，是比進程更小的可以獨立運行的基本單位。

特點：線程的劃分尺度小于進程，這使多線程程序擁有高并發性，進程在運行時各自內存單元相互獨立，線程之間內存共享，這使多線程編程可以擁有更好的性能和用戶體驗。

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

15.請說出同步線程及線程調度相關的方法？

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

sleep()：使一個正在運行的線程處于睡眠狀態，是一個靜態方法，調用此方法要處理InterruptedException異常；

notify()：喚醒一個處于等待狀態的線程，當然在調用此方法的時候，并不能確切的喚醒某一個等待狀態的線程，而是由JVM確定喚醒哪個線程，而且與優先級無關；

notityAll()：喚醒所有處于等待狀態的線程，該方法并不是將對象的鎖給所有線程，而是讓它們競爭，只有獲得鎖的線程才能進入就緒狀態；

注意：java 5通過Lock接口提供了顯示的鎖機制，Lock接口中定義了加鎖（lock()方法）和解鎖（unLock()方法），增強了多線程編程的靈活性及對線程的協調。

16.啟動一個線程是調用run()方法還是start()方法？

啟動一個線程是調用 start()方法，使線程所代表的虛擬處理機處于可運行狀態，這意味著它可以由 JVM 調度并執行，這并不意味著線程就會立即運行。

run()方法是線程啟動后要進行回調（callback）的方法。

全部教程
主站蜘蛛池模板： 久热天堂| 77成人网| 亚洲天堂成人在线 | 成人亚洲综合 | 欧美成人伦理 | 欧美黄色一级视频 | 免费看一级黄色毛片 | 九九精品免视看国产成人 | 最近中文字幕在线观看 | xx顶级欧美熟妞xxhd | 欧美久在线观看在线观看 | 可以看的黄网 | 国产精品福利无圣光一区二区 | 欧美福利 | 色avv| 欧美亚洲综合网 | 一级片aaaaaa| 香蕉视频国产精品人 | 一区二区在线看 | 玖草福利视频 | 最近2019免费中文字幕6 | 一级成人生活片免费看 | 国产麻豆a一级毛片爽爽影院 | free性欧美另类巨大 | 最近免费字幕中文大全视频 | 欧美日韩国产高清视频 | 免费看午夜高清性色生活片 | 一级欧美在线的视频 | 久久成人乱小说 | 激情影院成人区免费观看视频 | 免费成人福利视频 | 亚洲一区在线视频 | 手机看片日韩高清国产欧美 | 55夜色66夜色国产亚洲精品区 | 午夜影院网页 | 亚洲制服丝袜在线观看 | 国产亚洲午夜精品 | 在线免费观看黄色大片 | 欧美一区二区三区精品影视 | 国产在线观看一区二区三区四区 | 久久精品视频久久 |