public class RequestHandler {

    public String sendPostRequest(String requestURL,
                                  HashMap<String, String> postDataParams) {

        URL url;

        StringBuilder sb = new StringBuilder();
        try {
            url = new URL(requestURL);

            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setReadTimeout(15000);
            conn.setConnectTimeout(15000);
            conn.setRequestMethod("POST");
            conn.setDoInput(true);
            conn.setDoOutput(true);


            OutputStream os = conn.getOutputStream();
            BufferedWriter writer = new BufferedWriter(
                    new OutputStreamWriter(os, "UTF-8"));
            writer.write(getPostDataString(postDataParams));

            writer.flush();
            writer.close();
            os.close();
            int responseCode = conn.getResponseCode();

            if (responseCode == HttpsURLConnection.HTTP_OK) {
                BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                sb = new StringBuilder();
                String response;
                while ((response = br.readLine()) != null){
                    sb.append(response);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return sb.toString();
    }

    private String getPostDataString(HashMap<String, String> params) throws UnsupportedEncodingException {
        StringBuilder result = new StringBuilder();
        boolean first = true;
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (first)
                first = false;
            else
                result.append("&");

            result.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            result.append("=");
            result.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }

        return result.toString();
    }

}

在我看来，线程并不是进行套接字连接的最有效的方式，但它们确实在运行线程方面提供了最多的功能。我这么说是因为根据经验，长时间运行线程会导致设备非常热且资源密集。即使是一个简单的while(正确)也会在几分钟内使手机发热。如果你说UI交互不重要，也许AsyncTask是好的，因为它们是为长期流程设计的。这只是我的看法。

更新

请忽略我以上的回答!早在2011年，我就回答了这个问题，当时我对Android的经验远不如现在。我上面的回答是误导性的，被认为是错误的。我把它留在那里，因为很多人在下面评论纠正我，我已经吸取了教训。

There are far better other answers on this thread, but I will at least give me more proper answer. There is nothing wrong with using a regular Java Thread; however, you should really be careful about how you implement it because doing it wrong can be very processor intensive (most notable symptom can be your device heating up). AsyncTasks are pretty ideal for most tasks that you want to run in the background (common examples are disk I/O, network calls, and database calls). However, AsyncTasks shouldn't be used for particularly long processes that may need to continue after the user has closed your app or put their device to standby. I would say for most cases, anything that doesn't belong in the UI thread, can be taken care of in an AsyncTask.

AsyncTask用于执行一些后台计算并将结果发布到UI线程(带有可选的进度更新)。既然你不关心UI，那么处理器或线程似乎更合适。

您可以生成一个后台线程，并通过使用处理程序的post方法将消息传递回主线程。

线程:

你可以在不影响UI线程的情况下使用新的线程来执行长期运行的后台任务。从java线程，你不能更新UI线程。

由于普通线程在Android架构中用处不大，因此引入了线程的辅助类。

您可以在线程性能文档页面中找到查询的答案。

处理程序:

Handler允许您发送和处理与线程的MessageQueue关联的Message和Runnable对象。每个Handler实例都与单个线程和该线程的消息队列相关联。

Handler有两个主要用途:

将消息和可运行程序安排在未来的某个时间点执行; 将要在与自己的线程不同的线程上执行的操作排队。

AsyncTask:

AsyncTask允许正确和简单地使用UI线程。该类允许您执行后台操作并在UI线程上发布结果，而无需操作线程和/或处理程序。

缺点:

默认情况下，应用程序将它创建的所有AsyncTask对象推入一个线程。因此，它们以串行方式执行，与主线程一样，一个特别长的工作包会阻塞队列。由于这个原因，使用AsyncTask来处理持续时间短于5毫秒的工作项。 AsyncTask对象也是隐式引用问题的最常见的肇事者。AsyncTask对象也存在与显式引用相关的风险。

HandlerThread:

您可能需要一种更传统的方法来在长时间运行的线程上执行工作块(不像AsyncTask，它应该用于5ms的工作负载)，并且需要一些手动管理工作流的能力。处理程序线程实际上是一个长时间运行的线程，它从队列中获取工作并对其进行操作。

ThreadPoolExecutor:

该类管理一组线程的创建，设置它们的优先级，并管理如何在这些线程之间分配工作。随着工作负载的增加或减少，该类将启动或销毁更多的线程以适应工作负载。

如果工作负载比较大，单个HandlerThread不够用，那么可以使用ThreadPoolExecutor

然而，我想有一个套接字连接运行在服务。这应该运行在一个处理程序或线程，甚至一个AsyncTask?UI交互根本不需要。它对我使用的性能有影响吗?

因为UI交互不是必需的，你可能不需要AsyncTask。普通线程用处不大，因此HandlerThread是最好的选择。因为你必须维护套接字连接，主线程上的Handler一点用都没有。创建一个HandlerThread并从HandlerThread的循环程序中获取一个Handler。

 HandlerThread handlerThread = new HandlerThread("SocketOperation");
 handlerThread.start();
 Handler requestHandler = new Handler(handlerThread.getLooper());
 requestHandler.post(myRunnable); // where myRunnable is your Runnable object. 

如果希望与UI线程通信，可以使用另外一个Handler来处理响应。

final Handler responseHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            //txtView.setText((String) msg.obj);
            Toast.makeText(MainActivity.this,
                    "Foreground task is completed:"+(String)msg.obj,
                    Toast.LENGTH_LONG)
                    .show();
        }
    };

在Runnable中，您可以添加

responseHandler.sendMessage(msg);

关于实现的更多细节可以在这里找到:

Android:在线程中吐司

如果我们看一下源代码，就会发现AsyncTask和Handler完全是用Java编写的。(不过也有一些例外。但这不是重点)

所以在AsyncTask或Handler中没有什么魔力。这些类使开发人员的工作更加轻松。

例如:如果程序A调用方法A()，方法A()可以在程序A的不同线程中运行。我们可以通过以下代码轻松验证:

Thread t = Thread.currentThread();    
int id = t.getId();

为什么我们应该使用一个新线程的一些任务?你可以为它谷歌。很多很多原因，e。G:起重、长时间工作。

那么，线程，AsyncTask和处理程序之间的区别是什么?

AsyncTask和Handler是用Java写的(在内部它们使用线程)，所以我们可以用Handler或AsyncTask做的所有事情，我们也可以使用线程来实现。

Handler和AsyncTask能真正帮助什么?

最明显的原因是调用线程和工作线程之间的通信。 调用线程:调用工作线程执行某些任务的线程。调用线程不一定是UI线程)。当然，我们可以用其他方式在两个线程之间进行通信，但是由于线程安全，存在许多缺点(和危险)。

这就是为什么我们应该使用Handler和AsyncTask。这些类为我们做了大部分工作，我们只需要知道要重写哪些方法。

Handler和AsyncTask之间的区别是:当Caller线程是一个UI线程时使用AsyncTask。 这是android文档说的:

AsyncTask允许正确和简单地使用UI线程。这个类 允许执行后台操作，并在UI上发布结果 线程，而不必操作线程和/或处理程序

我想强调两点:

1)易于使用UI线程(所以，当调用线程是UI线程时使用)。

2)不需要操纵处理程序。(意思是:你可以使用Handler而不是AsyncTask，但AsyncTask是一个更简单的选择)。

在这篇文章中有很多东西我还没有说，例如:什么是UI线程，或者为什么它更容易。你必须知道每个类背后的一些方法并使用它，你才会完全理解其中的原因。

@:当你阅读Android文档时，你会看到:

Handler允许您发送和处理Message和Runnable对象 与线程的messagqueuue相关联

这种描述乍一看可能很奇怪。我们只需要了解每个线程都有每个消息队列(就像一个待办事项列表)，并且线程将接收每条消息，直到消息队列为空(就像我们完成工作并上床睡觉一样)。因此，当Handler通信时，它只是给调用线程一个消息，它将等待处理。

复杂?只要记住Handler可以安全地与调用线程通信。

就像Vogella网站上关于Android后台处理的教程，AsyncTask和Loaders一样:

Handler类可用于注册到线程，并提供一个简单的通道将数据发送到该线程。

AsyncTask类封装了后台进程的创建和与主线程的同步。它还支持报告正在运行的任务的进度。

线程基本上是多线程的核心元素，开发人员使用它有以下缺点:

如果您使用Java线程，则必须处理以下需求 在你自己的代码中: 如果将结果返回到用户界面，则与主线程同步 没有取消线程的默认值 没有默认线程池 Android中没有处理配置更改的默认值

关于AsyncTask，正如Android开发者参考所说:

AsyncTask enables proper and easy use of the UI thread. This class allows to perform background operations and publish results on the UI thread without having to manipulate threads and/or handlers. AsyncTask is designed to be a helper class around Thread and Handler and does not constitute a generic threading framework. AsyncTasks should ideally be used for short operations (a few seconds at the most.) If you need to keep threads running for long periods of time, it is highly recommended you use the various APIs provided by the java.util.concurrent package such as Executor, ThreadPoolExecutor and FutureTask.

2015年5月更新:我找到了一个涵盖这个主题的优秀系列讲座。

这是谷歌搜索:道格拉斯施密特讲座android并发和同步 这是YouTube上第一节课的视频 所有这些都是来自范德堡大学的CS 282 (2013): Android系统编程的一部分。这是YouTube播放列表 道格拉斯·施密特似乎是个出色的讲师

重要提示:如果你正在考虑使用AsyncTask来解决线程问题，你应该首先检查ReactiveX/RxAndroid，以获得更合适的编程模式。有一个很好的资源可以让你得到一个概览，那就是学习RxJava 2 for Android的例子。