new Thread的弊端及Java四种线程池的使用-阿里云开发者社区

介绍new Thread的弊端及Java四种线程池的使用，对Android同样适用。本文是基础篇，后面会分享下线程池一些高级功能。

1、new Thread的弊端

执行一个异步任务你还只是如下new Thread吗？

new Thread(new Runnable() {

    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}).start();

那你就out太多了，new Thread的弊端如下：

a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。

2、Java 线程池

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

(1). newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

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() {

        @Override
        public void run() {
            System.out.println(index);
        }
    });
}

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

(2). newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
    final int index = i;
    fixedThreadPool.execute(new Runnable() {

        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。

定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。

(3) newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {

    @Override
    public void run() {
        System.out.println("delay 3 seconds");
    }
}, 3, TimeUnit.SECONDS);

表示延迟3秒执行。

定期执行示例代码如下：

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

    @Override
    public void run() {
        System.out.println("delay 1 seconds, and excute every 3 seconds");
    }
}, 1, 3, TimeUnit.SECONDS);

表示延迟1秒后每3秒执行一次。

ScheduledExecutorService比Timer更安全，功能更强大，后面会有一篇单独进行对比。

(4)、newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
    final int index = i;
    singleThreadExecutor.execute(new Runnable() {

        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

结果依次输出，相当于顺序执行各个任务。

现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作，文件操作，应用批量安装，应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。

3. 实例演示Android异步加载图片

给大家演示异步加载图片的分析过程。让大家了解异步加载图片的好处，以及如何更新UI。
首先给出main.xml布局文件：
简单来说就是 LinearLayout 布局，其下放了2个TextView和5个ImageView。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <TextView
        android:text="图片区域开始"
        android:id="@+id/textView2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    <ImageView
        android:id="@+id/imageView1"
        android:layout_height="wrap_content"
        android:src="@drawable/icon"
        android:layout_width="wrap_content" />
    <ImageView
        android:id="@+id/imageView2"
        android:layout_height="wrap_content"
        android:src="@drawable/icon"
        android:layout_width="wrap_content" />
    <ImageView
        android:id="@+id/imageView3"
        android:layout_height="wrap_content"
        android:src="@drawable/icon"
        android:layout_width="wrap_content" />
    <ImageView
        android:id="@+id/imageView4"
        android:layout_height="wrap_content"
        android:src="@drawable/icon"
        android:layout_width="wrap_content" />
    <ImageView
        android:id="@+id/imageView5"
        android:layout_height="wrap_content"
        android:src="@drawable/icon"
        android:layout_width="wrap_content" />
    <TextView
        android:text="图片区域结束"
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
</LinearLayout>

我们将演示的过程是异步从服务器上下载5张不同图片，依次放入这5个ImageView。上下2个TextView 是为了方便我们看是否阻塞了UI的显示。
当然 AndroidManifest.xml 文件中要配置好网络访问权限。

 <uses-permission android:name="android.permission.INTERNET" />

1)Handler+Runnable模式
我们先看一个并不是异步线程加载的例子，而是使用 Handler+Runnable模式。
注意这里不是新开的线程，这里的代码其实是在UI主线程中下载图片的。
我们运行下面代码时，会发现它其实是阻塞了整个界面的显示，需要所有图片都加载完成后，才能显示界面。

package com.szy.textviewimagedemo;

import java.io.IOException;
import java.net.URL;

import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.SystemClock;
import android.util.Log;
import android.widget.ImageView;

/**
 *@author coolszy
 *@date 2012-2-13
 *@blog http://blog.92coding.com
 *
 */
public class MainActivity extends Activity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
        loadImage("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.imageView2);
        loadImage("http://cache.soso.com/30d/img/web/logo.gif", R.id.imageView3);
        loadImage("http://csdnimg.cn/www/images/csdnindex_logo.gif", R.id.imageView4);
        loadImage("http://images.cnblogs.com/logo_small.gif", R.id.imageView5);
    }

    private Handler handler = new Handler();

    private void loadImage(final String url, final int id)
    {
        handler.post(new Runnable()
        {
            public void run()
            {
                Drawable drawable = null;
                try
                {
                    drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");
                } catch (IOException e)
                {
                    Log.i("MainActivity", e.getMessage());
                }
                if (drawable == null)
                {
                    Log.i("MainActivity", "null drawable");
                } else
                {
                    Log.i("MainActivity", "not null drawable");
                }
                // 为了测试缓存而模拟的网络延时
                SystemClock.sleep(2000);
                ((ImageView) MainActivity.this.findViewById(id)).setImageDrawable(drawable);
            }
        });
    }
}

2)Handler+Thread+Message模式
这种模式使用了线程，所以可以看到异步加载的效果。
核心代码：

package com.szy.textviewimagedemo;

import java.io.IOException;
import java.net.URL;

import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.util.Log;
import android.widget.ImageView;

/**
 *@author coolszy
 *@date 2012-2-13
 *@blog http://blog.92coding.com
 *
 */
public class MainActivity extends Activity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Log.i("MainActivity", "MainThread ID:"+Thread.currentThread().getId());
        loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
        loadImage("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.imageView2);
        loadImage("http://cache.soso.com/30d/img/web/logo.gif", R.id.imageView3);
        loadImage("http://csdnimg.cn/www/images/csdnindex_logo.gif", R.id.imageView4);
        loadImage("http://images.cnblogs.com/logo_small.gif", R.id.imageView5);
    }

    final Handler handler = new Handler()
    {
        @Override
        public void handleMessage(Message msg)
        {
            Log.i("MainActivity", "UpdateUIThread ID:"+Thread.currentThread().getId());
            ((ImageView) MainActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable) msg.obj);
        }
    };

    // 采用handler+Thread模式实现多线程异步加载
    private void loadImage(final String url, final int id)
    {
        Thread thread = new Thread()
        {
            @Override
            public void run()
            {
                Drawable drawable = null;
                try
                {
                    Log.i("MainActivity", "Thread ID:"+Thread.currentThread().getId());
                    drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
                } catch (IOException e)
                {
                    Log.i("MainActivity", e.getMessage());
                }

                // 模拟网络延时
                SystemClock.sleep(2000);

                Message message = handler.obtainMessage();
                message.arg1 = id;
                message.obj = drawable;
                handler.sendMessage(message);
            }
        };
        thread.start();
        thread = null;
    }
}

这时候我们可以看到实现了异步加载，界面打开时，五个ImageView都是没有图的，然后在各自线程下载完后才把图自动更新上去。

3)Handler+ExecutorService(线程池)+MessageQueue模式
能开线程的个数毕竟是有限的，我们总不能开很多线程，对于手机更是如此。
这个例子是使用线程池。Android拥有与Java相同的ExecutorService实现，我们就使用它。
线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。
下面的演示例子是创建一个可重用固定线程数的线程池。
核心代码

package com.szy.textviewimagedemo;

import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.SystemClock;
import android.util.Log;
import android.widget.ImageView;

/**
 *@author coolszy
 *@date 2012-2-13
 *@blog http://blog.92coding.com
 *
 */
public class MainActivity extends Activity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Log.i("MainActivity", "MainThread ID:"+Thread.currentThread().getId());
        loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
        loadImage("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.imageView2);
        loadImage("http://cache.soso.com/30d/img/web/logo.gif", R.id.imageView3);
        loadImage("http://csdnimg.cn/www/images/csdnindex_logo.gif", R.id.imageView4);
        loadImage("http://images.cnblogs.com/logo_small.gif", R.id.imageView5);
    }

    private Handler handler = new Handler();

    private ExecutorService executorService = Executors.newFixedThreadPool(5);

    // 引入线程池来管理多线程
    private void loadImage(final String url, final int id)
    {
        executorService.submit(new Runnable()
        {
            public void run()
            {
                try
                {
                    Log.i("MainActivity", "Thread ID:"+Thread.currentThread().getId());
                    final Drawable drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
                    // 模拟网络延时
                    SystemClock.sleep(2000);
                    handler.post(new Runnable()
                    {
                        public void run()
                        {
                            Log.i("MainActivity", "UpdateUIThread ID:"+Thread.currentThread().getId());
                            ((ImageView) MainActivity.this.findViewById(id)).setImageDrawable(drawable);
                        }
                    });
                } catch (Exception e)
                {
                    throw new RuntimeException(e);
                }
            }
        });
    }
}

这里我们象第一步一样使用了
handler.post(new Runnable() { }) 更新前段显示当然是在UI主线程，我们还有 executorService.submit(new Runnable() { }) 来确保下载是在线程池的线程中。

4)Handler+ExecutorService(线程池)+MessageQueue+缓存模式
下面比起前一个做了几个改造:
把整个代码封装在一个类中，同时为了避免出现同时多次下载同一幅图的问题,使用了本地缓存封装的类:

package com.szy.textviewimagedemo;

import java.lang.ref.SoftReference;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.os.SystemClock;
import android.util.Log;

/**
 *@author coolszy
 *@date 2012-2-13
 *@blog http://blog.92coding.com
 */

public class AsyncImageLoader
{
    // 为了加快速度，在内存中开启缓存（主要应用于重复图片较多时，或者同一个图片要多次被访问，比如在ListView时来回滚动）
    public Map<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>();

    private ExecutorService executorService = Executors.newFixedThreadPool(5); // 固定五个线程来执行任务
    private final Handler handler = new Handler();

    /**
     *
     * @param imageUrl
     *            图像url地址
     * @param callback
     *            回调接口
     * @return 返回内存中缓存的图像，第一次加载返回null
     */
    public Drawable loadDrawable(final String imageUrl, final ImageCallback callback)
    {
        // 如果缓存过就从缓存中取出数据
        if (imageCache.containsKey(imageUrl))
        {
            SoftReference<Drawable> softReference = imageCache.get(imageUrl);
            if (softReference.get() != null)
            {
                Log.i("MainActivity", "图片存在缓存中.");
                return softReference.get();
            }
        }
        // 缓存中没有图像，则从网络上取出数据，并将取出的数据缓存到内存中
        executorService.submit(new Runnable()
        {
            public void run()
            {
                try
                {
                    Log.i("MainActivity", "下载图片...");
                    final Drawable drawable = loadImageFromUrl(imageUrl);
                    imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
                    handler.post(new Runnable()
                    {
                        public void run()
                        {
                            callback.imageLoaded(drawable);
                        }
                    });
                } catch (Exception e)
                {
                    throw new RuntimeException(e);
                }
            }
        });
        return null;
    }

    // 从网络上取数据方法
    protected Drawable loadImageFromUrl(String imageUrl)
    {
        try
        {
            // 测试时，模拟网络延时，实际时这行代码不能有
            SystemClock.sleep(2000);
            return Drawable.createFromStream(new URL(imageUrl).openStream(), "image.png");

        } catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }

    // 对外界开放的回调接口
    public interface ImageCallback
    {
        // 注意 此方法是用来设置目标对象的图像资源
        public void imageLoaded(Drawable imageDrawable);
    }
}

说明：
final参数是指当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
这里使用SoftReference 是为了解决内存不足的错误（OutOfMemoryError）的。

前端调用:

package com.szy.textviewimagedemo;

import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.widget.ImageView;

/**
 *@author coolszy
 *@date 2012-2-13
 *@blog http://blog.92coding.com
 *
 */
public class MainActivity extends Activity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);
        loadImage("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.imageView2);
        loadImage("http://cache.soso.com/30d/img/web/logo.gif", R.id.imageView3);
        loadImage("http://csdnimg.cn/www/images/csdnindex_logo.gif", R.id.imageView4);
        loadImage("http://images.cnblogs.com/logo_small.gif", R.id.imageView5);
    }

    private AsyncImageLoader asyncImageLoader = new AsyncImageLoader();

    // 引入线程池，并引入内存缓存功能,并对外部调用封装了接口，简化调用过程
    private void loadImage(final String url, final int id)
    {
        // 如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
        Drawable cacheImage = asyncImageLoader.loadDrawable(url, new AsyncImageLoader.ImageCallback()
        {
            // 请参见实现：如果第一次加载url时下面方法会执行
            public void imageLoaded(Drawable imageDrawable)
            {
                ((ImageView) findViewById(id)).setImageDrawable(imageDrawable);
            }
        });
        if (cacheImage != null)
        {
            ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
        }
    }
}

new Thread的弊端及Java四种线程池的使用

1、new Thread的弊端

2、Java 线程池

3. 实例演示Android异步加载图片

热门文章

最新文章

相关课程

相关电子书

相关实验场景

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

new Thread的弊端及Java四种线程池的使用

1、new Thread的弊端

2、Java 线程池

3. 实例演示Android异步加载图片

热门文章

最新文章

相关课程

相关电子书

相关实验场景