• <nav id="wkkge"><strong id="wkkge"></strong></nav>
  • <menu id="wkkge"></menu>
  • 第一部分 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)的方法。

     

    全部教程
  • <nav id="wkkge"><strong id="wkkge"></strong></nav>
  • <menu id="wkkge"></menu>
  • 面对面棋牌游戏