Java的一些題目

jokester 發(fā)布于2019-08-16 10:44 / 3153人閱讀

摘要：需要注意的是對于方法或者代碼塊，當(dāng)出現(xiàn)異常時，會自動釋放當(dāng)前線程占用的鎖，因此不會由于異常導(dǎo)致出現(xiàn)死鎖現(xiàn)象。用于實現(xiàn)線程間的通信，它是為了解決難以使用的問題。

速度StringBuilder>StringBuffer>String，StringBuffer線程安全

線程安全的集合有：Vector、Stack、HashTable、ConcurrentHashMap、

CopyOnWriteXXX(如CopyOnWriteArrayList)

ClassLoader

程序在啟動的時候，并不會一次性加載程序所要用的所有class文件，而是根據(jù)程序的需要，通過Java的類加載機(jī)制（ClassLoader）來動態(tài)加載某個class文件到內(nèi)存當(dāng)中的，從而只有class文件被載入到了內(nèi)存之后，才能被其它class所引用。所以ClassLoader就是用來動態(tài)加載class文件到內(nèi)存當(dāng)中用的。Java默認(rèn)提供的三個ClassLoader。BootStrap ClassLoader：稱為啟動類加載器，是Java類加載層次中最頂層的類加載器，負(fù)責(zé)加載JDK中的核心類庫，如：rt.jar、resources.jar、charsets.jar等。
Extension ClassLoader：稱為擴(kuò)展類加載器，負(fù)責(zé)加載Java的擴(kuò)展類庫，默認(rèn)加載JAVA_HOME/jre/lib/ext/目下的所有jar。
App ClassLoader：稱為系統(tǒng)類加載器，負(fù)責(zé)加載應(yīng)用程序classpath目錄下的所有jar和class文件。
ClassLoader使用的是雙親委托模型來搜索類的，每個ClassLoader實例都有一個父類加載器的引用（不是繼承的關(guān)系，是一個包含的關(guān)系），虛擬機(jī)內(nèi)置的類加載器（Bootstrap ClassLoader）本身沒有父類加載器，但可以用作其它ClassLoader實例的的父類加載器。
JVM在判定兩個class是否相同時，不僅要判斷兩個類名是否相同，而且要判斷是否由同一個類加載器實例加載的。只有兩者同時滿足的情況下，JVM才認(rèn)為這兩個class是相同的
Java ClassLoader原理

synchronized lock

淺談Java并發(fā)編程系列（五）Java并發(fā)編程之線程同步

當(dāng)一個線程正在訪問一個對象的synchronized方法，那么其他線程不能訪問該對象的其他synchronized方法，因為一個對象只有一把鎖，當(dāng)一個線程獲取了該對象的鎖之后，其他線程無法獲取該對象的鎖，所有無法訪問該對象的其他synchronized方法。
當(dāng)一個線程正在訪問一個對象的synchronized方法，那么其他線程能訪問該對象的非synchronized方法。因為非synchronized方法不需要獲取該對象的鎖。
如果一個線程A需要訪問對象object1的synchronized方法fun1，另外一個線程B需要訪問對象object2的synchronized方法fun1，即使object1和object2是同一類型，也不會產(chǎn)生線程安全問題，因為他們訪問的是不同的對象，所以不存在互斥問題。
如果一個線程執(zhí)行一個對象的非static synchronized方法，另一個線程執(zhí)行這個對象所屬類的static synchronized方法，此時不會發(fā)生互斥現(xiàn)象，因為訪問static synchronized方法占用的是類鎖，而訪問非static synchronized方法占用的是對象鎖，所以不存在互斥現(xiàn)象。
需要注意的是：對于synchronized方法或者synchronized代碼塊，當(dāng)出現(xiàn)異常時，JVM會自動釋放當(dāng)前線程占用的鎖，因此不會由于異常導(dǎo)致出現(xiàn)死鎖現(xiàn)象。

顯式鎖ReentrantLock則可以將鎖的獲得和釋放分開。同時顯式鎖可以提供輪訓(xùn)鎖和定時鎖，同時可以提供公平鎖或者非公平鎖。

ReentrantLock和Condition的關(guān)系

在ReentrantLock類中有一個重要的函數(shù)newCondition()，該函數(shù)用于獲取lock上的一個條件，也就是說Condition是和Lock綁定的。Condition用于實現(xiàn)線程間的通信，它是為了解決Object.wait()、notify()、notifyAll()難以使用的問題。

public class MyArrayBlockingQueue {

    // 數(shù)據(jù)數(shù)組
    private final T[] items;
    // 鎖
    private final Lock mLock = new ReentrantLock();
    // 數(shù)組滿的條件
    private Condition notFull = mLock.newCondition();
    // 數(shù)組空的條件
    private Condition notEmpty = mLock.newCondition();

    // 頭部
    private int head;
    // 尾部
    private int tail;
    // 數(shù)據(jù)數(shù)量
    private int count;

    public MyArrayBlockingQueue(int maxSize) {
        // TODO Auto-generated constructor stub
        items = (T[]) new Object[maxSize];
    }

    public MyArrayBlockingQueue() {
        // TODO Auto-generated constructor stub
        this(10);
    }

    public void put(T t) {

        mLock.lock();

        try {

            // 如果數(shù)據(jù)已滿,等待
            while (count == getCapacity()) {
                System.out.println("數(shù)據(jù)已滿，請等待");
                notFull.await();
            }

            System.out.println("存入數(shù)據(jù)");

            items[tail] = t;
            if (++tail == getCapacity()) {
                tail = 0;
            }

            ++count;
            // 喚醒等待數(shù)據(jù)的線程
            notEmpty.signalAll();

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            mLock.unlock();
        }
    }

    public T take() {

        mLock.lock();

        try {

            // 如果數(shù)組數(shù)據(jù)為空，則阻塞
            while (count == 0) {
                System.out.println("還沒有數(shù)據(jù)，等待");
                notEmpty.await();
            }

            System.out.println("取出數(shù)據(jù)");

            T t = items[head];
            items[head] = null;

            if (++head == getCapacity()) {
                head = 0;
            }

            --count;
            // 喚醒添加數(shù)據(jù)的線程
            notFull.signalAll();
            return t;

        } catch (InterruptedException e) {
            // TODO: handle exception
        } finally {
            mLock.unlock();
        }

        return null;
    }

    public int getCapacity() {
        return items.length;
    }

    public int size() {
        mLock.lock();
        try {
            return count;
        } finally {
            mLock.unlock();
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        final MyArrayBlockingQueue mQueue = new MyArrayBlockingQueue<>(
                5);

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                while (true) {

                    for(int i  = 0;i < 3;i++)
                    mQueue.put("just");
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }

            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                while (true) {
                    
                    mQueue.take();

                }
            }
        }).start();

    }

}

結(jié)果打印
存入數(shù)據(jù)
存入數(shù)據(jù)
存入數(shù)據(jù)
取出數(shù)據(jù)
取出數(shù)據(jù)
取出數(shù)據(jù)
還沒有數(shù)據(jù)，等待
存入數(shù)據(jù)
存入數(shù)據(jù)
存入數(shù)據(jù)
取出數(shù)據(jù)
取出數(shù)據(jù)
取出數(shù)據(jù)
還沒有數(shù)據(jù)，等待

當(dāng)時看到這段代碼我就想到一個問題：如果一個線程lock()對象后被掛起還沒有unlock，那么另外一個線程就拿不到鎖了（lock()操作會掛起），那么就無法通知(notify)前一個線程，這樣豈不是“死鎖”了？
再回頭看代碼，不管take()還是put()，在進(jìn)入lock.lock()后唯一可能釋放鎖的操作就是await()了。也就是說await()操作實際上就是釋放鎖，然后掛起線程，一旦條件滿足就被喚醒，再次獲取鎖！

await源碼如下

public final void await() throws InterruptedException {  
    if (Thread.interrupted())  
        throw new InterruptedException();  
    Node node = addConditionWaiter();  
    int savedState = fullyRelease(node);  
    int interruptMode = 0;  
    while (!isOnSyncQueue(node)) {  
        LockSupport.park(this);  
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)  
            break;  
    }  
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)  
        interruptMode = REINTERRUPT;  
    if (node.nextWaiter != null)  
        unlinkCancelledWaiters();  
    if (interruptMode != 0)  
        reportInterruptAfterWait(interruptMode);  
}

完整的await()操作是安裝如下步驟進(jìn)行的：

將當(dāng)前線程加入Condition鎖隊列。特別說明的是，這里不同于AQS的隊列，這里進(jìn)入的是Condition的FIFO隊列。后面會具體談到此結(jié)構(gòu)。進(jìn)行2。
釋放鎖。這里可以看到將鎖釋放了，否則別的線程就無法拿到鎖而發(fā)生死鎖。進(jìn)行3。
自旋(while)掛起，直到被喚醒或者超時或者CACELLED等。進(jìn)行4。
獲取鎖(acquireQueued)。并將自己從Condition的FIFO隊列中釋放，表明自己不再需要鎖（我已經(jīng)拿到鎖了）。

介紹Condition的數(shù)據(jù)結(jié)構(gòu)。我們知道一個Condition可以在多個地方被await*()，那么就需要一個FIFO的結(jié)構(gòu)將這些Condition串聯(lián)起來，然后根據(jù)需要喚醒一個或者多個（通常是所有）。所以在Condition內(nèi)部就需要一個FIFO的隊列。

//conditon 的兩個屬性
private transient Node firstWaiter;  
private transient Node lastWaiter;

這兩個節(jié)點就是描述一個FIFO的隊列。我們再結(jié)合前面提到的節(jié)點（Node）數(shù)據(jù)結(jié)構(gòu)。我們就發(fā)現(xiàn)Node.nextWaiter就派上用場了！nextWaiter就是將一系列的Condition.await*串聯(lián)起來組成一個FIFO的隊列。

wait和sleep的區(qū)別