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

简介: 介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用。本文是基础篇,后面会分享下线程池一些高级功能。1、new Thread的弊端执行一个异步任务你还只是如下new Thread吗?new Thread(new Runnable() { @Override public void run() {

介绍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);
        }
    }
}
相关文章
|
9天前
|
存储 Java 数据库连接
java多线程之线程通信
java多线程之线程通信
|
9天前
|
安全 Java 开发者
深入理解Java并发编程:线程安全与性能优化
【4月更文挑战第9天】本文将深入探讨Java并发编程的核心概念,包括线程安全和性能优化。我们将详细解析Java中的同步机制,包括synchronized关键字、Lock接口以及并发集合等,并探讨它们如何影响程序的性能。此外,我们还将讨论Java内存模型,以及它如何影响并发程序的行为。最后,我们将提供一些实用的并发编程技巧和最佳实践,帮助开发者编写出既线程安全又高效的Java程序。
22 3
|
10天前
|
Java
Java 并发编程:深入理解线程池
【4月更文挑战第8天】本文将深入探讨 Java 中的线程池技术,包括其工作原理、优势以及如何使用。线程池是 Java 并发编程的重要工具,它可以有效地管理和控制线程的执行,提高系统性能。通过本文的学习,读者将对线程池有更深入的理解,并能在实际开发中灵活运用。
|
8天前
|
算法 Java 开发者
Java中的多线程编程:概念、实现与性能优化
【4月更文挑战第9天】在Java编程中,多线程是一种强大的工具,它允许开发者创建并发执行的程序,提高系统的响应性和吞吐量。本文将深入探讨Java多线程的核心概念,包括线程的生命周期、线程同步机制以及线程池的使用。接着,我们将展示如何通过继承Thread类和实现Runnable接口来创建线程,并讨论各自的优缺点。此外,文章还将介绍高级主题,如死锁的预防、避免和检测,以及如何使用并发集合和原子变量来提高多线程程序的性能和安全性。最后,我们将提供一些实用的性能优化技巧,帮助开发者编写出更高效、更稳定的多线程应用程序。
|
6天前
|
安全 算法 Java
深入理解Java并发编程:线程安全与性能优化
【4月更文挑战第11天】 在Java中,高效的并发编程是提升应用性能和响应能力的关键。本文将探讨Java并发的核心概念,包括线程安全、锁机制、线程池以及并发集合等,同时提供实用的编程技巧和最佳实践,帮助开发者在保证线程安全的前提下,优化程序性能。我们将通过分析常见的并发问题,如竞态条件、死锁,以及如何利用现代Java并发工具来避免这些问题,从而构建更加健壮和高效的多线程应用程序。
|
11天前
|
Java
Java并发编程:深入理解线程池
【4月更文挑战第7天】在现代软件开发中,多线程编程已经成为一种不可或缺的技术。为了提高程序性能和资源利用率,Java提供了线程池这一强大工具。本文将深入探讨Java线程池的原理、使用方法以及如何根据实际需求定制线程池,帮助读者更好地理解和应用线程池技术。
15 0
|
1天前
|
存储 安全 Java
Java中的容器,线程安全和线程不安全
Java中的容器,线程安全和线程不安全
6 1
|
1天前
|
存储 缓存 监控
Java线程池
Java线程池
11 1
|
2天前
|
设计模式 运维 安全
深入理解Java并发编程:线程安全与性能优化
【4月更文挑战第15天】在Java开发中,多线程编程是提升应用程序性能和响应能力的关键手段。然而,它伴随着诸多挑战,尤其是在保证线程安全的同时如何避免性能瓶颈。本文将探讨Java并发编程的核心概念,包括同步机制、锁优化、线程池使用以及并发集合等,旨在为开发者提供实用的线程安全策略和性能优化技巧。通过实例分析和最佳实践的分享,我们的目标是帮助读者构建既高效又可靠的多线程应用。
|
4天前
|
Java 程序员 编译器
Java中的线程同步与锁优化策略
【4月更文挑战第14天】在多线程编程中,线程同步是确保数据一致性和程序正确性的关键。Java提供了多种机制来实现线程同步,其中最常用的是synchronized关键字和Lock接口。本文将深入探讨Java中的线程同步问题,并分析如何通过锁优化策略提高程序性能。我们将首先介绍线程同步的基本概念,然后详细讨论synchronized和Lock的使用及优缺点,最后探讨一些锁优化技巧,如锁粗化、锁消除和读写锁等。