苍井空番号,蜜桃成人无码av在线观看一电影,欧洲尺码日本尺码专线中老年

說到線程就要說說線程機制 Handler,Looper,MessageQueue 可以說是三座大山了

Handler

Handler 其實就是一個處理者，或者說一個發送者，它會把消息發送給消息隊列，也就是Looper，然后在一個無限循環隊列中進行取出消息的操作 mMyHandler.sendMessage(mMessage); 這句話就是我耗時操作處理完了，我發送過去了! 然后在接受的地方處理！簡單理解是不是很簡單。

一般我們在項目中異步操作都是怎么做的呢？

    // 這里開啟一個子線程進行耗時操作
    new Thread() {
        @Override
        public void run() {
            .......
            Message mMessage = new Message();
            mMessage.what = 1;
            //在這里發送給消息隊列
            mMyHandler.sendMessage(mMessage);
            }
        }.start();
    /**
     * 這里就是處理的地方 通過msg.what進行處理分辨
     */
    class MyHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
            //取出對應的消息進行處理
                ........
            }
        }
    }

那么我們的消息隊列是在什么地方啟動的呢?跟隨源碼看一看

# ActivityThread.main
public static void main(String[] args) {
        //省略代碼。。。。。
        
        //在這里創建了一個消息隊列！
        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        //這句我也沒有看懂 這不是一直都不會執行的么
        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        //消息隊列跑起來了！
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

    public Handler(Callback callback, boolean async) {
        mLooper = Looper.myLooper();
        //注意看這里拋出的異常 如果這里mLooper==null
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        //獲取消息隊列
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

以上操作Android系統就獲取并且啟動了一個消息隊列，過多的源碼這里不想去描述，免的占用很多篇幅

這里說一下面試常見的一個問題，就是在子線程中可不可以創建一個Handler，其實是可以的，但是誰這么用啊- -

    new Thread() {
        Handler mHandler = null;
        @Override
        public void run() {
            //在這里獲取
            Looper.prepare();
            mHandler = new Handler();
            //在這里啟動
            Looper.loop();
        }
    }.start();

多線程的創建

一般我們在開發過程中要開啟一個線程都是直接

        new Thread() {
            @Override
            public void run() {
                doing.....
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                doing.....
            }
        }).start();

注意看，一個傳遞了Runnable對象，另一個沒有,但是這兩個有什么不同，為什么要衍生出2個呢？
這里不去看源碼，簡單敘述一下，實際上Thread是Runnabled的一個包裝實現類，Runnable只有一個方法，就是run(),在這里以前也想過，為什么Runnable只有一個方法呢，后來的某一次交談中也算是找到一個答案，可能是因為多拓展，可能JAVA語言想拓展一些其他的東西，以后就直接在Runnable再寫了。不然我是沒有想到另一答案為什么都要傳遞一個Runnable,可能就像我們開發中的baseActivity一樣吧

線程常用的操作方法

wait() 當一個線程執行到了wait() 就會進去一個和對象有關的等待池中，同時失去了釋放當前對象的機所，使其他線程可以訪問，也就是讓其他線程可以調用notify()喚醒
sleep() 調用得線程進入睡眠狀態，不能該改變對象的機鎖，其他線程不能訪問
join() 就等自己完事
yidld 你急你先來

簡單的白話敘述其實也就是這樣，希望能看看demo然后理解一下。

一些其他的方法，Callable,Future,FutureTask

Runnable是線程管理的拓展接口，不可以運用于線程池,所以你總要有方法可以在線程池中管理啊所以Callable,Future,FutureTask就是可以在線程池中開啟線程的接口。

Future定義了規范的接口，如get(),isDone(),isCancelled()...FutureTask是他的實現類這里簡單說一下他的用法

/**
 * ================================================
 * 作    者：夏沐堯  Github地址：https://github.com/XiaMuYaoDQX
 * 版    本：1.0
 * 創建日期： 2018/1/10
 * 描    述：
 * 修訂歷史：
 * ================================================
 */
class FutureDemo {
    //創建一個單例線程
    static ExecutorService mExecutor = Executors.newSingleThreadScheduledExecutor();

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ftureWithRunnable();
        ftureWithCallable();
        ftureTask();
    }

    /**
     * 沒有指定返回值，所以返回的是null,向線程池中提交的是Runnable
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private static void ftureWithRunnable() throws ExecutionException, InterruptedException {
        Future<?> result1 = mExecutor.submit(new Runnable() {
            @Override
            public void run() {
                fibc(20);
                System.out.println(Thread.currentThread().getName());
            }
        });
        System.out.println("Runnable" + result1.get());
    }

    /**
     * 提交了Callable，有返回值，可以獲取阻塞線程獲取到數值
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private static void ftureWithCallable() throws ExecutionException, InterruptedException {
        Future<Integer> result2 = mExecutor.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName());
                return fibc(20);
            }
        });
        System.out.println("Callable" + result2.get());
    }

    /**
     * 提交的futureTask對象
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private static void ftureTask() throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName());
                return fibc(20);
            }
        });
        mExecutor.submit(futureTask);
        System.out.println("futureTask" + futureTask.get());

    }

    private static int fibc(int num) {
        if (num == 0) {
            return 0;
        }
        if (num == 1) {
            return 1;
        }
        return fibc(num - 1) + fibc(num - 2);
    }
}

線程池

Java通過Executors提供線程池，分別為：

newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
newFixedThreadPool 創建一個定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。
newScheduledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

示例代碼

newCachedThreadPool
創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。示例代碼如下：

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   try {  
    Thread.sleep(index * 1000);  
   } catch (InterruptedException e) {  
    e.printStackTrace();  
   }  
   cachedThreadPool.execute(new Runnable() {  
    public void run() {  
     System.out.println(index);  
    }  
   });  
  }  
 }  
} 
線程池為無限大，當執行第二個任務時第一個任務已經完成，會復用執行第一個任務的線程，而不用每次新建線程。

newFixedThreadPool
創建一個定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。示例代碼如下：

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   fixedThreadPool.execute(new Runnable() {  
    public void run() {  
     try {  
      System.out.println(index);  
      Thread.sleep(2000);  
     } catch (InterruptedException e) {  
      e.printStackTrace();  
     }  
    }  
   });  
  }  
 }  
}  
因為線程池大小為3，每個任務輸出index后sleep 2秒，所以每兩秒打印3個數字。
定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()

newScheduledThreadPool
創建一個定長線程池，支持定時及周期性任務執行。延遲執行示例代碼如下：

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  scheduledThreadPool.schedule(new Runnable() {  
   public void run() {  
    System.out.println("delay 3 seconds");  
   }  
  }, 3, TimeUnit.SECONDS);  
 }  
}  
表示延遲3秒執行。

定期執行示例代碼如下：

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {  
   public void run() {  
    System.out.println("delay 1 seconds, and excute every 3 seconds");  
   }  
  }, 1, 3, TimeUnit.SECONDS);  
 }  
}  
表示延遲1秒后每3秒執行一次。

newSingleThreadExecutor

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   singleThreadExecutor.execute(new Runnable() {  
    public void run() {  
     try {  
      System.out.println(index);  
      Thread.sleep(2000);  
     } catch (InterruptedException e) {  
      e.printStackTrace();  
     }  
    }  
   });  
  }  
 }  
}

這里只是簡單敘述了一下線程的管理的各種方法,后續還會針對鎖進行講解
2018年1月17日下午8:19說到線程就要說說線程機制 Handler,Looper,MessageQueue 可以說是三座大山了

Handler

Handler 其實就是一個處理者，或者說一個發送者，它會把消息發送給消息隊列，也就是Looper，然后在一個無限循環隊列中進行取出消息的操作 mMyHandler.sendMessage(mMessage); 這句話就是我耗時操作處理完了，我發送過去了! 然后在接受的地方處理！簡單理解是不是很簡單。

一般我們在項目中異步操作都是怎么做的呢？

    // 這里開啟一個子線程進行耗時操作
    new Thread() {
        @Override
        public void run() {
            .......
            Message mMessage = new Message();
            mMessage.what = 1;
            //在這里發送給消息隊列
            mMyHandler.sendMessage(mMessage);
            }
        }.start();
    /**
     * 這里就是處理的地方 通過msg.what進行處理分辨
     */
    class MyHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
            //取出對應的消息進行處理
                ........
            }
        }
    }

那么我們的消息隊列是在什么地方啟動的呢?跟隨源碼看一看

# ActivityThread.main
public static void main(String[] args) {
        //省略代碼。。。。。
        
        //在這里創建了一個消息隊列！
        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        //這句我也沒有看懂 這不是一直都不會執行的么
        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        //消息隊列跑起來了！
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

    public Handler(Callback callback, boolean async) {
        mLooper = Looper.myLooper();
        //注意看這里拋出的異常 如果這里mLooper==null
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        //獲取消息隊列
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

以上操作Android系統就獲取并且啟動了一個消息隊列，過多的源碼這里不想去描述，免的占用很多篇幅

這里說一下面試常見的一個問題，就是在子線程中可不可以創建一個Handler，其實是可以的，但是誰這么用啊- -

    new Thread() {
        Handler mHandler = null;
        @Override
        public void run() {
            //在這里獲取
            Looper.prepare();
            mHandler = new Handler();
            //在這里啟動
            Looper.loop();
        }
    }.start();

多線程的創建

一般我們在開發過程中要開啟一個線程都是直接

        new Thread() {
            @Override
            public void run() {
                doing.....
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                doing.....
            }
        }).start();

線程常用的操作方法

wait() 當一個線程執行到了wait() 就會進去一個和對象有關的等待池中，同時失去了釋放當前對象的機所，使其他線程可以訪問，也就是讓其他線程可以調用notify()喚醒
sleep() 調用得線程進入睡眠狀態，不能該改變對象的機鎖，其他線程不能訪問
join() 就等自己完事
yidld 你急你先來

簡單的白話敘述其實也就是這樣，希望能看看demo然后理解一下。

一些其他的方法，Callable,Future,FutureTask

Future定義了規范的接口，如get(),isDone(),isCancelled()...FutureTask是他的實現類這里簡單說一下他的用法

/**
 * ================================================
 * 作    者：夏沐堯  Github地址：https://github.com/XiaMuYaoDQX
 * 版    本：1.0
 * 創建日期： 2018/1/10
 * 描    述：
 * 修訂歷史：
 * ================================================
 */
class FutureDemo {
    //創建一個單例線程
    static ExecutorService mExecutor = Executors.newSingleThreadScheduledExecutor();

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ftureWithRunnable();
        ftureWithCallable();
        ftureTask();
    }

    /**
     * 沒有指定返回值，所以返回的是null,向線程池中提交的是Runnable
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private static void ftureWithRunnable() throws ExecutionException, InterruptedException {
        Future<?> result1 = mExecutor.submit(new Runnable() {
            @Override
            public void run() {
                fibc(20);
                System.out.println(Thread.currentThread().getName());
            }
        });
        System.out.println("Runnable" + result1.get());
    }

    /**
     * 提交了Callable，有返回值，可以獲取阻塞線程獲取到數值
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private static void ftureWithCallable() throws ExecutionException, InterruptedException {
        Future<Integer> result2 = mExecutor.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName());
                return fibc(20);
            }
        });
        System.out.println("Callable" + result2.get());
    }

    /**
     * 提交的futureTask對象
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private static void ftureTask() throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName());
                return fibc(20);
            }
        });
        mExecutor.submit(futureTask);
        System.out.println("futureTask" + futureTask.get());

    }

    private static int fibc(int num) {
        if (num == 0) {
            return 0;
        }
        if (num == 1) {
            return 1;
        }
        return fibc(num - 1) + fibc(num - 2);
    }
}

線程池

Java通過Executors提供線程池，分別為：

newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
newFixedThreadPool 創建一個定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。
newScheduledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

示例代碼

newCachedThreadPool
創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。示例代碼如下：

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   try {  
    Thread.sleep(index * 1000);  
   } catch (InterruptedException e) {  
    e.printStackTrace();  
   }  
   cachedThreadPool.execute(new Runnable() {  
    public void run() {  
     System.out.println(index);  
    }  
   });  
  }  
 }  
} 
線程池為無限大，當執行第二個任務時第一個任務已經完成，會復用執行第一個任務的線程，而不用每次新建線程。

newFixedThreadPool
創建一個定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。示例代碼如下：

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   fixedThreadPool.execute(new Runnable() {  
    public void run() {  
     try {  
      System.out.println(index);  
      Thread.sleep(2000);  
     } catch (InterruptedException e) {  
      e.printStackTrace();  
     }  
    }  
   });  
  }  
 }  
}  
因為線程池大小為3，每個任務輸出index后sleep 2秒，所以每兩秒打印3個數字。
定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()

newScheduledThreadPool
創建一個定長線程池，支持定時及周期性任務執行。延遲執行示例代碼如下：

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  scheduledThreadPool.schedule(new Runnable() {  
   public void run() {  
    System.out.println("delay 3 seconds");  
   }  
  }, 3, TimeUnit.SECONDS);  
 }  
}  
表示延遲3秒執行。

定期執行示例代碼如下：

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {  
   public void run() {  
    System.out.println("delay 1 seconds, and excute every 3 seconds");  
   }  
  }, 1, 3, TimeUnit.SECONDS);  
 }  
}  
表示延遲1秒后每3秒執行一次。

newSingleThreadExecutor

public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   singleThreadExecutor.execute(new Runnable() {  
    public void run() {  
     try {  
      System.out.println(index);  
      Thread.sleep(2000);  
     } catch (InterruptedException e) {  
      e.printStackTrace();  
     }  
    }  
   });  
  }  
 }  
}

這里只是簡單敘述了一下線程的管理的各種方法,后續還會針對鎖進行講解
2018年1月17日下午8:19

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Android 對于線程，線程池的操作

Android 對于線程，線程池的操作

Handler

一般我們在項目中異步操作都是怎么做的呢？

這里說一下面試常見的一個問題，就是在子線程中可不可以創建一個Handler，其實是可以的，但是誰這么用啊- -

多線程的創建

線程池

Handler

一般我們在項目中異步操作都是怎么做的呢？

這里說一下面試常見的一個問題，就是在子線程中可不可以創建一個Handler，其實是可以的，但是誰這么用啊- -

多線程的創建

線程池

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Android 對于線程，線程池的操作

Handler

一般我們在項目中異步操作都是怎么做的呢？

這里說一下面試常見的一個問題，就是在子線程中可不可以創建一個Handler，其實是可以的，但是誰這么用啊- -

多線程的創建

線程池

Handler

一般我們在項目中異步操作都是怎么做的呢？

這里說一下面試常見的一個問題，就是在子線程中可不可以創建一個Handler，其實是可以的，但是誰這么用啊- -

多線程的創建

線程池

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频