怎么用java線程監控Lock接口的類

這篇文章主要介紹“怎么用java線程監控Lock接口的類”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“怎么用java線程監控Lock接口的類”文章能幫助大家解決問題。

1. 進程和線程的區別

2. 靜態代理模式

• Thread：代理角色

• 實現Runnable接口的類：真實角色

• 有代理就有機會在執行真實角色對象方法之前或之后加入額外的動作。

3. 常用方法

Thread t=Thread.currentThread() //獲取當前線程對象
Thread.currentThread().toString() //輸出當前線程對象的[name,priority,group]
t.getName() //獲取線程的名稱
t.setName() //修改線程的名稱
Thread t=new Thread(MyRunnable,"自定義線程名稱")

4. 線程控制方法

t.join() 讓線程t插隊
Thread.yield() 禮讓，讓出CPU的使用權一次（從運行態進入就緒態）
Thread.sleep()

5. 同步鎖

• 同步代碼塊

synchronized(obj){
  ...
}

obj為同步對象（只能是對象），且一般選擇為共享資源的對象。可以是this當前對象，也可以是其他對象。

• 同步方法

public synchronized ... methodName(args...){
  ...
}

同步方法的同步對象為this。

6. 使用Callable接口啟動線程

使用繼承Thread或者使用Runnable接口靜態代理的方式，存在如下缺點：

• 沒有返回值

• 不支持泛型

• 異常必須處理，不能外拋throws。

為此可以實現Callable接口，重寫call()方法。

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        String[] gentleman={"春申君","信陵君","平原君","孟嘗君"};
        int index=(int) (Math.random()*3);
        return gentleman[index];
    }
}

class Test{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable call=new MyCallable();
        FutureTask<String> task=new FutureTask<>(call);
        Thread t=new Thread(task);
        t.start();
        //獲取返回值
        System.out.println("春秋四公子："+task.get());
        //判斷是否執行完成
        System.out.println("任務是否執行完成："+task.isDone());
    }
}

7. 線程同步鎖Lock

監控實現Lock接口的類。
java.util.concurrent.lock中的Lock是一個接口，它的實現類是一個Java類，而不是關鍵字。在線程同步中比synchronized更靈活。如果同步代碼有異常，要將unLock()放到finally中。

public class CountRunnable implements Runnable {
    private int count = 0;

    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //synchronized (this) {
            try {
                lock.lock();
                count++;
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "執行操作：count=" + count);
            } finally {
                lock.unlock();
            }
        }
    }
}

class Test {
    public static void main(String[] args) {
        CountRunnable cr = new CountRunnable();
        Thread t1 = new Thread(cr, "A");
        Thread t2 = new Thread(cr, "B");
        Thread t3 = new Thread(cr, "C");

        t1.start();
        t2.start();
        t3.start();
    }
}

Lock與synchronized的區別

• Lock是顯式鎖，需要手動開啟和關閉，而隱式鎖synchronized不需要。

• Lock只有代碼塊鎖，而synchronized有代碼塊鎖和方法鎖。

• 使用Lock鎖JVM將花費更少的時間來調度線程。有更好的性能和擴展性（提供更多的子類）。

• Lock本質是一個臨界區鎖。

8. 線程池

• 執行Runnable任務

public class Test1 {
    public static void main(String[] args) {
        //線程池中只有一個線程
//        ExecutorService pool1 = Executors.newSingleThreadExecutor();
        //線程池中有固定數量的線程
        ExecutorService pool1 = Executors.newFixedThreadPool(10);
        //線程池中的線程數是動態改變的（按需）
//        ExecutorService pool1 = Executors.newCachedThreadPool();
        //執行大量任務
        for (int i = 0; i < 20; i++) {
            final int n = i;
            Runnable cmd = new Runnable() {
                @Override
                public void run() {
                    System.out.println("開始執行：" + n);
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("執行結束：" + n);
                }
            };
            pool1.execute(cmd);
        }
        pool1.shutdown();
    }
}

• 執行Callable任務

public class Test2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //線程池中只有一個線程
//        ExecutorService pool1 = Executors.newSingleThreadExecutor();
        //線程池中有固定數量的線程
        ExecutorService pool1 = Executors.newFixedThreadPool(10);
        //線程池中的線程數是動態改變的（按需）
//        ExecutorService pool1 = Executors.newCachedThreadPool();

        List<Future> list = new ArrayList<>();

        //執行大量任務
        for (int i = 0; i < 20; i++) {
            final int n = i;
            Callable<Integer> task = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    Thread.sleep(500);
                    return (int) (Math.random() * 10) + 1;
                }
            };
            Future f = pool1.submit(task);
            list.add(f); //先把任務都分發出去
//            System.out.println(f.get()); //要等到每個線程執行結束才得到返回值，效率較低
        }
        System.out.println("分發異步執行");
        for (Future f : list) { //最后再收集返回結果
            System.out.println(f.get());
        }
        System.out.println("獲得最終執行結果");
        pool1.shutdown();
    }
}

9. ThreadLocal在數據庫連接上的應用

ThreadLocal經常應用在數據庫連接和session管理上。

關于“怎么用java線程監控Lock接口的類”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。