线程和异步任务

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 线程和异步任务
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        #region 线程休眠
        /// <summary>
        /// 线程休眠
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            // Thread 线程 Sleep 休眠
            // sleep 线程休眠3s
            Thread.Sleep(3000);
            MessageBox.Show("主线程休眠");
        }
        #endregion

        #region 是否后台线程
        /// <summary>
        /// 是否是后台线程
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        Thread th;// 全局的线程
        private void button2_Click(object sender, EventArgs e)
        {
            // ThreadStart 定义线程的委托方法
            ThreadStart ts = new ThreadStart(Test1);

            // 创建线程
            th = new Thread(ts);

            // 是否是后台线程
            // 后台线程随着主线程退出而退出
            th.IsBackground = true;

            // 开启线程
            th.Start();
        }
        public void Test1()
        {
            try
            {
                // 组织分线程的执行 不会阻止主线程的执行
                Thread.Sleep(10000);
                MessageBox.Show("分线程执行");
            }
            catch (Exception)
            {

                throw;
            }
        }
        #endregion

        /// <summary>
        /// 窗体正在关闭的事件 停止分线程
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (th!=null)
            {
                th.Abort();// 中断分线程
            }
        }

        #region 带参数的线程的方法
        /// <summary>
        /// 带参数的线程点击按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button3_Click(object sender, EventArgs e)
        {
            Thread th = new Thread(Test2);
            th.Start(2);// 开启分线程 传递参数

            new Thread(() =>
            {
                // 分线程
            }).Start();
        }
        public void Test2(object a)
        {
            MessageBox.Show("检测出来的半点个数为:" + Convert.ToInt16(a));
        }
        #endregion

        #region 线程池
        private void button4_Click(object sender, EventArgs e)
        {
            // ThreadPool 线程池 将方法排入队列以便执行 方法在线程池里面有可用的线程的时候执行
            // QueueUserWorkItem 用户工作队列
            // 参数一:线程方法
            // 参数二:传递参数
            ThreadPool.QueueUserWorkItem(obj =>
            {
                Thread.Sleep(10000);
                MessageBox.Show(obj.ToString());
            },2);
            // ThreadPool.SetMaxThreads;// 最大活跃的线程个数
            ThreadPool.QueueUserWorkItem(Test3, 2);
        }
        public void Test3(object a)
        {
            // 分线程不能更新UI
            // 特殊的属性可以直接更改
            // this.button4.BackColor = Color.Black;

            // this 窗体对象
            // Inoke 调用 回到窗体创建的线程更新UI
            // 同步执行委托方法
            //this.Invoke(new Action(() => 
            //{
            //    this.button4.Text = "更新UI";
            //}));

            // 异步执行委托方法
            this.BeginInvoke(new MethodInvoker(() =>
            {
                this.button4.Text = "更新UI";
            }));
        }
        #endregion

        #region Task异步任务实现分线程
        private void button5_Click(object sender, EventArgs e)
        {
            #region 创建任务的三种方式
            #region 1.使用New Task 创建
            Task t1 = new Task(new Action(() =>
            {
                Console.WriteLine("ZW1");
            }));
            t1.Start();// 开启任务
            #endregion
            #region 2.Task使用静态方法 Run
            Task.Run(new Action(() =>
            {
                Console.WriteLine("ZW2");
            }));
            #endregion
            #region 3.使用任务工厂创建
            Task.Factory.StartNew(() =>
            {
                Console.WriteLine("ZW3");
            });
            #endregion
            #endregion
        }
        #endregion

        #region Async和Await
        private async void button6_Click(object sender, EventArgs e)
        {
            // 使用async和await解决多层嵌套回调
            await Task.Run(Test5);
            await Task.Run(Test6);
        }
        public void Test5()
        {
            Console.WriteLine("ZW");
        }
        public void Test6()
        {
            Console.WriteLine("zw");
        }
        #endregion

        #region Thread 应用异常捕获场景
        private void button7_Click(object sender, EventArgs e)
        {
            Thread th = new Thread(Test7);
            th.Start(0);
        }
        public void Test7(object a)
        {
            try
            {
                int num1 = (int)a;
                int num2 = 10 / num1;
                Console.WriteLine(num2);
            }
            catch (Exception ex)
            {
                // Exception 所有异常的基类
                // IndexOutOfRangeException 索引值越界的异常
                // IOException 文件读写的异常
                // DivideByZeroException 除数为零的异常
                // DirectoryNotFoundException 文件夹不存在异常
                Console.WriteLine(ex.Message);// 打印异常信息
            }
            finally
            {

            }
        }
        #endregion

        #region Task异常捕获
        private void button8_Click(object sender, EventArgs e)
        {
            Task t1 = new Task(Test8);
            t1.Start();
            try
            {
                t1.Wait();// 这种只能在Release环境下捕获异常
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
        public void Test8()
        {
            int a = 10;
            int b = 0;
            int c = a / b;
        }
        #endregion
    }
}

<think>嗯,用户想了解Java中异步任务线程的实现方法。首先,我需要整理一下常见的实现方式,确保覆盖不同的方法,并且结构清晰。 首先,记得用户提到的几个引用,比如使用Thread类、线程池、FutureCompletableFuture,还有@Async注解。这些应该作为主要的实现方式来介绍。不过引用中提到的@Async可能用户没有用MQ或者RPC,所以需要强调原生方法。 然后,每个方法需要给出代码示例,这样用户更容易理解。比如继承Thread类,实现Runnable接口,线程池的用法,还有CompletableFuture的链式调用。要注意代码的正确性,比如线程池的创建参数,还有CompletableFuture的异常处理。 接下来,用户可能关心异步任务的应用场景,比如日志处理、邮件发送这些不需要即时响应的操作。需要结合引用中的例子,说明异步处理如何提升性能。 还要注意用户提到的系统级指令,比如行内数学公式要用$...$,但这里可能用不上数学公式,所以可能不需要处理。不过要确保代码块用正确的格式,比如三个反引号加python,不过这里是Java,所以需要调整代码块的标记。 可能用户对线程安全的问题不太清楚,是否需要提到?比如共享资源的问题,但用户的问题主要是实现方式,所以可能在优化部分提到线程池参数配置或者使用线程安全的数据结构。 最后,生成的相关问题需要与主题紧密相关,比如性能优化、异常处理、应用场景对比,以及Spring中的异步机制。这样用户如果有进一步的问题,可以引导他们深入探索。 现在需要检查引用内容是否准确对应到各个实现方式。引用1提到多线程Queue异步队列处理,可能对应线程池的任务队列。引用23都是关于Thread类继承Thread的方式,还有实现Runnable。所以需要正确标注引用来源,确保每个实现方法都有对应的引用支持。 可能用户是开发者,需要具体的教程式步骤,所以每个实现方式分步骤说明,代码示例要完整,比如main方法中如何启动线程线程池的执行过程等。 还要注意回答结构,先介绍四种方式,再讲应用场景,再讲优化。最后的问题部分要覆盖常见的疑问点,比如性能分析、异常处理、应用场景比较Spring整合。</think>### Java异步任务与多线程实现方式 Java中实现异步任务线程的核心目标是提升程序执行效率,避免阻塞主线程。以下是四种常用实现方式,结合代码示例场景说明。 --- #### **1. 继承`Thread`类** 通过继承`Thread`类并重写`run()`方法,定义异步任务逻辑。 ```java public class MyThread extends Thread { @Override public void run() { System.out.println("异步任务执行,线程ID:" + Thread.currentThread().getId()); // 模拟耗时操作 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } // 调用方式 public static void main(String[] args) { MyThread thread = new MyThread(); thread.start(); // 启动新线程 } ``` **特点**:简单直接,但Java单继承限制灵活性[^3]。 --- #### **2. 实现`Runnable`接口** 更推荐的方式,避免单继承限制,任务线程分离。 ```java public class MyRunnable implements Runnable { @Override public void run() { System.out.println("Runnable任务执行,线程ID:" + Thread.currentThread().getId()); } } // 调用方式 public static void main(String[] args) { Thread thread = new Thread(new MyRunnable()); thread.start(); } ``` **特点**:灵活性高,适合任务与执行逻辑解耦[^2]。 --- #### **3. 使用线程池(`ExecutorService`)** 通过线程池管理线程生命周期,避免频繁创建/销毁线程的开销。 ```java ExecutorService executor = Executors.newFixedThreadPool(4); // 创建4个线程的池 // 提交任务 executor.submit(() -> { System.out.println("线程任务执行,线程ID:" + Thread.currentThread().getId()); }); executor.shutdown(); // 关闭线程池 ``` **场景**:适用于高并发任务,如异步批量处理数据[^1]。 --- #### **4. `CompletableFuture`(Java 8+)** 支持链式调用的异步编程,可组合多个异步任务。 ```java CompletableFuture.supplyAsync(() -> { System.out.println("CompletableFuture任务执行,线程ID:" + Thread.currentThread().getId()); return "结果"; }).thenAccept(result -> { System.out.println("处理结果:" + result); }); ``` **优势**:支持回调、异常处理,适合复杂异步流程。 --- ### **异步任务的应用场景** 1. **非阻塞操作**:如日志记录、邮件发送等无需即时响应的任务[^1]。 2. **批量处理**:将大量数据推送到队列,由线程异步处理[^1]。 3. **并行计算**:利用多线程加速计算密集型任务。 --- ### **优化建议** 1. **线程池参数调优**:根据任务类型(CPU密集型/IO密集型)调整核心线程数、队列容量[^1]。 2. **异步结果处理**:使用`Future`或`CompletableFuture`获取任务结果,避免阻塞。 3. **资源隔离**:为不同业务使用独立线程池,防止相互影响。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值