重拾Android之--多线程技术

重拾Android之–多线程技术

• 多线程的创建

1、继承Thread类实现多线程
2、实现Runnable接口实现多线程

// 继承Thread类实现多线程
public class MyThread extends Thread {
    @Override
    public void run() {
        Log.i("message", "多线程实现");
    }
}

MyThread myThread = new MyThread();
myThread.start();

// 实现Runnable接口实现多线程
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        Log.i("message", "runnable 实现多线程" + Thread.currentThread().getName());
    }
}

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

• 线程池的使用

Android中常用的几种线程池
1、newCachedThreadPool 缓存线程池
2、newFixedThreadPool 能控制最大的并发数的线程池
3、newSingleThreadExecutor 串行线程池
4、newSingleThreadScheduledExecutor 能定时执行的线程池

Demo:

// newCachedThreadPool
public void testCachedThreadPool() {
    ExecutorService service = Executors.newCachedThreadPool();
    for (int i = 0; i < 10; i++) {
        final int index = i;
        try {
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                Log.i("线程池", Thread.currentThread().getName() + " " + index);
            }
        });
    }
}

// newFixedThreadPool
private void testFixThread() {
    // 设置最大的并发数为2
    ExecutorService service = Executors.newFixedThreadPool(2);
    for (int i = 0; i < 10; i ++) {
        final int index = i;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                Log.i("线程池", Thread.currentThread().getName() + " " + index);
            }
        });
    }
}

// newSingleThreadExecutor 串行执行
private void testSingleThread() {
    ExecutorService service = Executors.newSingleThreadExecutor();
    for (int i = 0; i < 10; i ++) {
        final  int index = i;
        service.execute(new Runnable() {
            @Override
            public void run() {
                Log.i("线程池", Thread.currentThread().getName() + " " + index);
            }
        });
    }
}

// newSingleThreadScheduledExecutor 设置定时执行
private void testScheduled() {
    ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
    // 定时3秒后执行
//        scheduledExecutorService.schedule(new Runnable() {
//            @Override
//            public void run() {
//                Log.i("线程池", Thread.currentThread().getName());
//            }
//        },3, TimeUnit.SECONDS);

    // 定时3秒后执行，每隔2秒继续执行
    scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            Log.i("线程池", Thread.currentThread().getName());
        }
    }, 3, 2, TimeUnit.SECONDS);
}

• 异步消息处理机制（线程之间的通讯）

1、使用Handle类来实现
2、使用AsyncTask

Handle类来实现线程之间的通讯

// 在子线程中发送消息
new Thread(new Runnable() {
    @Override
    public void run() {
        // 发送空消息
        // handler.sendEmptyMessage(1);
        // 延时两秒发送一个空消息
        // handler.sendEmptyMessageDelayed(1, 2000);
        // 利用message来携带数据
        Message message = new Message();
        message.what = 2;
        message.obj = "obj";
        handler.sendMessage(message);
    }
}).start();

// 在Handler中处理子线程发送的数据
private Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case 1:
                // 主线程，接收到子线程传递的数据
                break;
            case 2:
                button.setText((String)msg.obj);
                break;
        }
    }
};
    
// 第二种、利用handler发送post回到主线程
handler.post(new Runnable() {
    @Override
    public void run() {
        // 在主线程
        Log.i("post", Thread.currentThread().getName());
        button.setText("post");
    }
});

// 发送延时post
handler.postDelayed(new Runnable() {
    @Override
    public void run() {
        // 在主线程
        Log.i("postDelayed", Thread.currentThread().getName());
        button.setText("post");
    }
}, 2000);

// 第三种 利用View的post方法回到主线程
button.post(new Runnable() {
    @Override
    public void run() {
        Log.i("button.post", Thread.currentThread().getName());
        button.setText("button.post");
    }
});

// 第四种 利用Activity的runOnUiThread方法
runOnUiThread(new Runnable() {
    @Override
    public void run() {
        Log.i("runOnUiThreadt", Thread.currentThread().getName());
        button.setText("runOnUiThread");
    }
});

AsyncTask

继承AsyncTask来实现异步任务，AsyncTask的泛型参数，第一个参数代表传入的参数，第二个代表返回当前任务的进度，第三个代表返回的参数类型

class MyAsyncTask extends AsyncTask<String, Integer, String> {
    // 后台任务执行之前调用，准备
    @Override
    protected void onPreExecute() {
        Log.i("message", "后台任务执行之前调用，准备");
    }

    @Override
    protected String doInBackground(String... strings) {
        // 后台任务 传入的参数 strings
        // 回调主线程进度
        publishProgress();
        Log.i("message", "doInBackground");
        return "返回的数据";
    }

    // 后台任务结束后在主线程执行
    @Override
    protected void onPostExecute(String s) {
        Log.i("message", "onPostExecute");
        button.setText(s);
    }

    // 回到主线程更新进度
    @Override
    protected void onProgressUpdate(Integer... values) {
        Log.i("message", "onProgressUpdate");
    }
}

//  使用
new MyAsyncTask().execute("传入的参数");