一些JavaSE學習程序中的思路整理(四)（主觀性強，持續更新中...）-有解無憂

一些JavaSE學習程序中的思路整理(四)（主觀性強，持續更新中...）
- 多執行緒編程：資源類&任務&運行機制的解耦合
- 關于重入鎖(ReentrantLock)的細節
- 條件物件配合重入鎖的使用
- synchronized關鍵字修飾非靜態方法與靜態方法
- 關于Java集合框架的綜述
- 關于鏈表LinkedList中添加洗掉物件的細節
- 陣列串列ArrayList的使用場景
- 散列集 HashSet & 樹集 TreeSet
- lambda運算式+Comparator介面實作與上述代碼中第二個樹集的按字串字典序排序相同的功能

一些JavaSE學習程序中的思路整理(四)（主觀性強，持續更新中...）

未經作者允許，不可轉載，如有錯誤，歡迎指正o(￣▽￣)o

多執行緒編程：資源類&任務&運行機制的解耦合

一下是《Java核心技術卷一》中的一個樣例，用多執行緒并發模擬銀行賬戶的轉賬程序，該樣例還未使用上鎖機制，是一個有問題的樣例，但是鑒于只是為了用于講解解耦合，所以無傷大雅，我寫了點注釋，算是到目前為止我所理解的解耦合

資源類

public class Bank {
    //final關鍵字必須初始化
    private final double[] accounts;

    //這里將原本的建構式屏蔽了
    public Bank(int n, double initialBalance) {
        accounts = new double[n];
        Arrays.fill(accounts, initialBalance);
    }

    //這里是資源類，定義了一次轉賬交易
    public void transfer(int from, int to, double amount) {
        if (accounts[from] < amount) return;
        System.out.println(Thread.currentThread().getName());
        accounts[from] -= amount;
        System.out.printf("%.2f from %d to %d\n", amount, from, to);
        accounts[to] += amount;
        System.out.printf("Total Balance: %.2f\n", getTotalBalance());
    }

    public double getTotalBalance() {
        double sum = 0;

        for (double a : accounts)
            sum += a;

        return sum;
    }

    public int size() {
        return accounts.length;
    }
}

測驗類

public class UnsynchBankTest {
    public static final int NACCOUNTS = 100;
    public static final double INITIAL_BALANCE = 1000;
    public static final double MAX_AMOUNT = 1000;
    public static final int DELAY = 10;

    public static void main(String[] args) {
        var bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
        for (int i = 0; i < NACCOUNTS; i++) {
            int fromAccount = i;
            Runnable r = () -> {
                try {
                    //假設作業系統采用搶占式，則即使是while回圈，在時間片耗盡后依舊需要釋放資源，保存當前行程執行的進度，進入可運行態
                    //這里將while回圈寫在Runnable函式式介面內，這時任務部分（多次執行轉賬）
                    while (true) {
                        int toAccount = (int) (bank.size() * Math.random());
                        double amount = MAX_AMOUNT * Math.random();
                        bank.transfer(fromAccount, toAccount, amount);
                        Thread.sleep((int) (DELAY * Math.random()));
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            //運行機制 （該demo中資源類只寫該類具有的功能，介面負責寫需要用資源類去執行的任務，最后執行緒實體負責運行執行緒）
            new Thread(r, String.valueOf(i)).start();
        }
    }
}

關于重入鎖(ReentrantLock)的細節

之所以稱之為重入鎖，是因為一個執行緒可以反復獲得已經擁有的鎖，鎖有一個持有計數來跟蹤對lock方法的嵌套呼叫，執行緒每次呼叫lock方法后都要unlock釋放鎖，被一個鎖保護的代碼可以呼叫另一個使用相同鎖的方法
假設有一個實體物件甲，它有一個方法①（甲.①）被重入鎖鎖定，而①中呼叫了方法②，那么呼叫②的時候也會封鎖甲物件，此時甲物件重入鎖的持有計數為2，當方法②退出時，持有計數變為1，當方法①退出時，持有計數變為0，執行緒釋放鎖
重入鎖默認時非公平鎖，公平鎖傾向于等待時間最長的執行緒，但是公平鎖要比常規鎖慢很多，人為強制干預執行緒的調度方式只適用于特定的環境

條件物件配合重入鎖的使用

newCondition()，回傳一個與這個鎖相關聯的條件物件（一個鎖可以有多個條件物件）
await()，將該執行緒放在這個條件物件所管理的等待集合
signalAll()，解除該條件等待集合中的所有執行緒的阻塞狀態
signal()，隨機解除該條件的等待集合中的某一個執行緒的阻塞狀態

下面依舊用銀行轉賬的這個例子稍作改寫，體驗一下執行緒安全下的隨機兩個賬戶的轉賬程序

資源類

public class Bank {
    //final關鍵字必須初始化
    private final double[] accounts;
    private ReentrantLock reentrantLock;
    private Condition sufficientFunds;

    //這里我將原本的建構式屏蔽了
    public Bank(int n, double initialBalance) {
        accounts = new double[n];
        Arrays.fill(accounts, initialBalance);
        reentrantLock = new ReentrantLock();
        //需要從一個特定的鎖物件獲得條件物件
        sufficientFunds = reentrantLock.newCondition();
    }

    //這里是資源類，定義了一次轉賬交易
    public void transfer(int from, int to, double amount) {
        reentrantLock.lock();
        try {
            //如果資金不足則需要進入等待集，等待singal（singalAll）命令回傳可運行態，每次重新獲得鎖，進入后從之前暫停的
            //地方繼續執行，所以有可能依舊會不滿足條件而進入等待集，并釋放鎖
            while (accounts[from] < amount)//通過控制while內的條件，就可以控制條件物件呼叫await的條件（使用if我認為這個不是原子操作，所以很可能會出現問題）
                sufficientFunds.await();//進入等待集，并釋放鎖
            System.out.println(Thread.currentThread().getName());
            accounts[from] -= amount;
            System.out.printf("%.2f from %d to %d\n", amount, from, to);
            accounts[to] += amount;
            System.out.printf("Total Balance: %.2f\n", getTotalBalance());
            //一旦完成一筆轉賬，那些等待集中的執行緒就有可能可以繼續執行，所以釋放所有等待集中的執行緒
            sufficientFunds.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

    public double getTotalBalance() {
        double sum = 0;

        for (double a : accounts)
            sum += a;

        return sum;
    }

    public int size() {
        return accounts.length;
    }
}

測驗類

public class UnsynchBankTest {
    public static final int NACCOUNTS = 100;
    public static final double INITIAL_BALANCE = 1000;
    public static final double MAX_AMOUNT = 1000;
    public static final int DELAY = 10;

    public static void main(String[] args) {
        var bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
        for (int i = 0; i < NACCOUNTS; i++) {
            int fromAccount = i;
            Runnable r = () -> {
                try {
                    //假設作業系統采用搶占式，則即使是while回圈，在時間片耗盡后依舊需要釋放資源，保存當前行程執行的進度，進入可運行態
                    //這里將while回圈寫在Runnable函式式介面內，這時任務部分（多次執行轉賬）
                    while (true) {
                        int toAccount = (int) (bank.size() * Math.random());
                        double amount = MAX_AMOUNT * Math.random();
                        bank.transfer(fromAccount, toAccount, amount);
                        Thread.sleep((int) (DELAY * Math.random()));
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            //運行機制 （該demo中資源類只寫該類具有的功能，介面負責寫需要用資源類去執行的任務，最后執行緒實體負責運行執行緒）
            new Thread(r, String.valueOf(i)).start();
        }
    }
}

synchronized關鍵字修飾非靜態方法與靜態方法

修飾實體方法：宏觀上可以理解為將鎖定該實體物件，當一個執行緒正在呼叫synchronized修飾的實體方法時，沒有其他執行緒可以呼叫該物件的該方法或者其他同步的實體方法（由synchronized修飾）
修飾靜態方法：宏觀上可以理解為將鎖定該類物件，沒有其他執行緒可以呼叫這個類的該靜態方法或者其他同步的靜態方法（由synchronized修飾）

以下是通過synchronized關鍵字和條件實作上述重入鎖與條件物件相同的功能的銀行轉賬例子

資源類

public class Bank {
    //final關鍵字必須初始化
    private final double[] accounts;

    //這里我將原本的建構式屏蔽了
    public Bank(int n, double initialBalance) {
        accounts = new double[n];
        Arrays.fill(accounts, initialBalance);
    }

    //java中每個物件都有內部鎖，宣告synchronized關鍵字，這個物件的鎖將保護整個方法
    public synchronized void transfer(int from, int to, double amount) throws InterruptedException {
        while (accounts[from] < amount)
            wait();     //只有一個條件物件，如果資金不足會呼叫wait方法，將當前執行緒放入wait管理的等待集中(阻塞)，并釋放鎖
        System.out.println(Thread.currentThread().getName());
        accounts[from] -= amount;
        System.out.printf("%.2f from %d to %d\n", amount, from, to);
        accounts[to] += amount;
        System.out.printf("Total Balance: %.2f\n", getTotalBalance());
        //無論是wait還是notifyAll和notify都是Object類的方法
        notifyAll();
    }

    public synchronized double getTotalBalance() {
        double sum = 0;

        for (double a : accounts)
            sum += a;

        return sum;
    }

    public int size() {
        return accounts.length;
    }
}

測驗類：未修改

但是使用內部鎖(synchronized)也存在一些缺陷：

不能中斷一個正在嘗試獲得鎖的執行緒
不能指定嘗試獲得鎖的超時時間
每個鎖僅有一個條件可能是不夠的

關于Java集合框架的綜述

抽象類：抽象類中必須有抽象方法，可以有實體方法，抽象類無法直接用new關鍵字初始化，可以通過繼承抽象類后由子類進行初始化，前提是該子類實作了抽象父類的所有抽象方法，否則子類依舊為抽象類
for each 回圈可以處理任何實作了Iterable介面的物件，這個介面只包含了一個抽象方法，而Java集合類的基本介面是Collection介面，而Collection介面擴展了Iterable介面（介面繼承介面），所以標準類別庫中的任何集合都可以使用for each回圈

public interface Iterable<E> {
	Iterator<E> iterator();//該方法回傳一個實作了Iterator介面的物件，這里用的是多型的方式（is-a）
	...
}

Iterator 迭代器介面

public interface Iterator<E> {
	E next();
	boolean hasNext();
	void remove();
	default void forEachRemaining(Consumer<? super E> action);
}

使用迭代器與for each遍歷集合中的元素的簡單示例，該樣例中只是展示迭代器和for each方法使用的邏輯，而不是可以直接運行的代碼，具體要結合Java標準集合實作類去使用

Collection<String> c = ...;
//Collection介面繼承額Iterable介面后獲得了它的iterator方法
Iterator<String> iter = c.iterator();
//用迭代器
while (iter.hasNext()) {
	String element = iter.next();
	do something with element
}
//用for each
for (String element : c) {
	do something with element
}

集合框架的家譜的由來：先定義了很多功能的集合介面（介面之間也有繼承，功能逐漸細分），接著由抽象類實作介面中的部分抽象方法（完成從介面到類的跨越，逐步實作需要的功能），隨著抽象類繼續被子類繼承，抽象方法全部被實作，最終得到了不同功能的實作類，（就是我們可以使用的Java集合實作類，它們有不同的功能實作，適合不同的應用場景）

關于鏈表LinkedList中添加洗掉物件的細節

LinkedList實體的add方法用于將物件添加到鏈表的尾部，但是無法添加的到鏈表的中間
集合類別庫提供了Iterator的一個子介面ListIterator（原因是Iterator介面只有四個功能，顯然是不夠的），其中包含add，remove等方法，可以使實作類通過迭代器向鏈表的中間插入洗掉物件，LinkdeList 類的 listIterator 方法回傳一個實作了 ListIterator 介面的迭代器物件，可以通過在這個迭代器物件上呼叫實體方法實作上述功能
關于迭代器指向的位置：可以理解為，迭代器位于兩個物件之間，起初位于第一個物件的左側，通過呼叫next方法移動到第一個與第二個物件之間，每次呼叫迭代器的add方法，將在迭代器“前”插入物件（或者理解為在迭代器處插入一個物件，然后迭代器指向新插入物件與之前右側的物件之間）
關于3中的插入操作用|表示迭代器位置，用字母表示物件則可以有四個插入位置：|ABC、A|BC、AB|C、ABC|
注意：實作了ListIterator介面的物件，該物件的remove方法和set方法都是去洗掉或者覆寫迭代器上一個越過的物件（next()與previous()方法執行后迭代器位置向后或者向前移動一個位置，并且回傳越過的物件）
上述提到的各種介面中的方法，在Java的實作類完成對實作了該介面的抽象類的繼承后，已經根據需求實作了對應的方法，這是Java集合實作類的設計者的作業（記得每個類可以單繼承，但是一個類可以實作多個介面，所以這是一個組裝+優化的程序）
關于linkedList的get方法，是一個“虛假”的隨機訪問下標物件的方法，它只有一個小的優化，當查詢位置大于size()/2時從鏈表的末尾開始依次查詢（如果使用了這個方法，你很可能用錯了資料結構）
實作了ListIterator介面的物件的nextIndex方法和previousIndex方法回傳該迭代器位置前后對應物件在鏈表中的下標，效率高（得益于迭代器保存當前位置的計數器），而集合物件獲取ListIterator迭代器物件的方法有一個多載：

ListIterator<String> listIterator = staff.listIterator(n);//回傳索引為n的物件與n-1物件之間的迭代器，效率低，畢竟對于鏈表，一切與索引有關的操作都很低效

并發修改例外（ConcurrentModificationException）：一個迭代器發現自己的集合結構被另一個迭代器修改了（發生在執行緒不同步的集合類中），集合可以跟蹤更改操作，但所謂的集合結構被修改不包括呼叫ListIterator.set()方法，Java并沒有將值的修改歸于集合結構發生了變化

陣列串列ArrayList的使用場景

ArrayList封裝了一個動態再分配的物件陣列，它是執行緒不同步的，而對于使用動態陣列，Vector類是執行緒同步的，兩個執行緒可以安全的訪問同一個vector物件，但是為了同步就會有額外開銷，所以如果在單執行緒中需要使用動態陣列，且不會發生兩個迭代器去操作集合的結構（不需要使用執行緒同步時）推薦使用ArrayList而不是使用Vector

散列集 HashSet & 樹集 TreeSet

散列集是無序集合，不可重復（Set都是不可重復集），用迭代器Iterator進行遍歷（而非ListIterator，這是用于有序集合的）Java散串列用鄰接表實作（陣列 + 鏈表），并根據使用情況進行資料結構的優化
樹集存盤有序集合，其排序使用紅黑樹，每次將一個元素添加到樹中，都會將其放置在正確的排序位置上，迭代器總是以有序的方式順序訪問每個元素，要使用樹集，必須能夠比較元素，這些元素必須實作Comparable介面或者構造集時必須提供一個Comparator，樹集雖快，但是構造比較函式有時不方便，所以根據需求進行選擇

知識點回顧：Java中 == 用于參考的直接比較，注意基本資料型別與物件參考在堆疊記憶體和堆記憶體的存盤方式

以下代碼通過實作Comparable介面和自定義類實作Comparator介面的兩種方式實作堆Item類的排序，第一種排序先按序號從小到大，序號相同按字串從小大到，第二種直接按字串從小到大排序

public class Test1 {
    public static void main(String[] args) {
        var parts = new TreeSet<Item>();
        parts.add(new Item("T", 1234));
        parts.add(new Item("A", 1234));
        parts.add(new Item("M", 9912));
        System.out.println(parts);

        //如果不通過實作Comparable介面的方式 可以通過自定義一個實作Comparator介面的類實作排序
        //下面會通過lambda運算式更方便的去使用Comparator介面實作自定義排序功能
        var sortByDescription = new TreeSet<Item>(new DescriptionComparator());

        sortByDescription.addAll(parts);
        System.out.println(sortByDescription);
    }
}

//自定義類實作Comparator介面，注意泛型介面的型別要對應樹集的泛型型別
class DescriptionComparator implements Comparator<Item> {

    @Override
    public int compare(Item o1, Item o2) {
        return o1.getDescription().compareTo(o2.getDescription());
    }
}

//一個類實作一個介面如果沒有完全實作介面的抽象方法，則該類為抽象類
class Item implements Comparable<Item> {
    private String description;
    private int partNumber;

    @Override
    public String toString() {
        return "Item{" +
                "description='" + description + '\'' +
                ", partNumber=" + partNumber +
                '}';
    }

    public Item(String description, int partNumber) {
        this.description = description;
        this.partNumber = partNumber;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        //所屬類名不同一定不同
        if (o == null || getClass() != o.getClass()) return false;
        //多型
        Item item = (Item) o;
        //這里比較兩個字串用的時Object類的方法？可以嗎？字串常量池？
        return partNumber == item.partNumber &&
                Objects.equals(description, item.description);
    }

    @Override
    public int hashCode() {
        return Objects.hash(description, partNumber);
    }

    @Override
    public int compareTo(Item o) {
        //第一個引數小回傳-1 相同回傳0 第一個引數大回傳1
        // 實作定義中的 從小大到排序，如此一來，只要第一個引數小時回傳1
        //則可以實作從大到小排序
        int diff = Integer.compare(partNumber, o.partNumber);
        //如果相同則按字典序（轉成位元組陣列比較）比較String的大小，從小到大
        return diff != 0 ? diff : description.compareTo(o.description);
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public int getPartNumber() {
        return partNumber;
    }

    public void setPartNumber(int partNumber) {
        this.partNumber = partNumber;
    }
}

lambda運算式+Comparator介面實作與上述代碼中第二個樹集的按字串字典序排序相同的功能

Java中有許多封裝代碼塊的介面，如Runnable，Comparator等，lambda運算式與這些介面是兼容的，對于只有一個抽象方法的介面，需要這種介面的物件時，就可以提供一個lambda運算式（而lambda運算式的引數串列就對應介面中抽象方法的引數串列，方法體也是相對應），這種介面稱為函式式介面，

		//如果不通過實作Comparable介面的方式 可以通過自定義一個實作Comparator介面的類實作排序
        //下面會通過lambda運算式更方便的去使用Comparator介面實作自定義排序功能
        //var sortByDescription = new TreeSet<Item>(new DescriptionComparator());
        //lambda運算式()中引數的型別可以不指定
        Comparator<Item> c = (o1, o2) -> {
            return o1.getDescription().compareTo(o2.getDescription());
        };
        var sortByDescription = new TreeSet<Item>(c);

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/251374.html

標籤：Java

上一篇：Spring實作宣告式事務

下一篇：一個程式員的自述