创建线程的几种方式(代码示例)

最新推荐文章于 2022-11-28 08:00:01 发布
最新推荐文章于 2022-11-28 08:00:01 发布
阅读量115 收藏
点赞数
文章标签： 操作系统 ui
原文链接：http://www.cnblogs.com/jx270/p/3583614.html
版权
创建线程的几种方式(代码示例) 
 
      

#region 方式2-1 启动线程(带输入参数的)

private void btn1_Click(object sender, EventArgs e)
 {
 MyObject obj = new MyObject(1, 2);//或者使用全局变量代替obj
 Thread thread = new Thread(obj.FunctionName);
 thread.Start();
 }

public class MyObject
 {
public int a1, b1;

public MyObject(int a, int b)
 {
 a1 = a;
 b1 = b;
 }

public void FunctionName()
 {
 MessageBox.Show("a:" + a1 + ",b:" + b1);
 }
 }
#endregion

#region 方式2-2 启动线程(带输入参数的)

private void btn2_Click(object sender, EventArgs e)
 {
//这个Thread类的构造方法的定义如下：
 Thread thread = new Thread(myStaticParamThreadMethod);
 thread.Start("通过委托的参数传值");
 }

public static void myStaticParamThreadMethod(Object obj)
 {
 MessageBox.Show(obj.ToString());
 }

//[ComVisibleAttribute(false)]
//public delegate void ParameterizedThreadStart(Object obj);

//public Thread(ParameterizedThreadStart start);

#endregion


#region 方式3 线程池技术

 RegisteredWaitHandle RW;

private void btn3_Click(object sender, EventArgs e)
 {
//ThreadPool.QueueUserWorkItem((objState) =>
//{
// //do something.. //from the thread pool.
//}, null);

 RW = ThreadPool.RegisterWaitForSingleObject(wait, new WaitOrTimerCallback(test), state, 1000, false);
 wait.Set();
 }

 AutoResetEvent wait = new AutoResetEvent(false);
object state = new object();

int count = 0;

/// <summary>
/// 会定时反复调用
/// </summary>
private void test(object state, bool timedOut)
 {
 SetText(DateTime.Now.ToString());
 count++;

if (count > 5) RW.Unregister(wait);//执行5次后，退出 
 }

/// <summary>
/// 调用UI线程,修改界面数据
/// </summary> 
public void SetText(string argText)
 {
if (lblResult.InvokeRequired)
 {
 lblResult.Invoke(new SetTextDelegateMethod(SetText), new[] { argText });
 }
else
 lblResult.Text = argText;
 }
public delegate void SetTextDelegateMethod(string argText);

#endregion

#region 方式4 使用BackgroundWorker

//支持：报告进度、支持完成回调、取消任务、暂停任务等

private BackgroundWorker Worker;

private void btn4_Click(object sender, EventArgs e)
 {
 Worker = new BackgroundWorker();
 Worker.WorkerReportsProgress = true;
 Worker.WorkerSupportsCancellation = true;
 Worker.DoWork += worker_DoWork;
 Worker.ProgressChanged += worker_ProgressChanged;
 Worker.RunWorkerCompleted += worker_RunWorkerCompleted;
 Worker.RunWorkerAsync();
 }

/// <summary>
/// 异步执行完毕，回到UI线程
/// </summary>
void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
 {
if (e.Cancelled) lblResult.Text = "取消成功！";
else lblResult.Text = "执行完成！";

测试捕获异常
//if (e.Error != null && !string.IsNullOrEmpty(e.Error.Message)) lblResult.Text = e.Error.Message;

//借助AsyncOperation.Post(SendOrPostCallback d, object arg)，
//在winform下使用这个函数,使得由SendOrPostCallback定义被封送回UI线程
 }

private void btn4Abort_Click(object sender, EventArgs e)
 {
 Worker.CancelAsync();
 }

void worker_DoWork(object sender, DoWorkEventArgs e)
 {
 BackgroundWorker _worker = sender as BackgroundWorker;
for (int i = 1; i < 101; i++)
 {
 _worker.ReportProgress(i, "执行到第" + i + "个");
 Thread.Sleep(100);

//此时在非UI线程中执行代码，执行下行代码会出错
//lblResult.Text = "aaa"; //线程间操作无效: 从不是创建控件“lblResult”的线程访问它。

//这里判断一下是否用户要求取消后台进行，并可以尽早退出
if (_worker.CancellationPending)
 {
 e.Cancel = true;
return;
 }

测试捕获异常
//if (i == 35) throw new Exception("在执行到i=" + i + "时候出错！");
 }
 }

void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
 {
this.lblResult.Text = e.ProgressPercentage.ToString() + " " + e.UserState;
 }

#endregion
 
      
 
     
 
     
 
      
namespace WinFormsApp_CreateAThread
{
partial class Form1
    {
/// <summary>
/// 必需的设计器变量。
/// </summary>
private System.ComponentModel.IContainer components = null;

/// <summary>
/// 清理所有正在使用的资源。
/// </summary>
/// <param name="disposing">如果应释放托管资源，为 true；否则为 false。</param>
protected override void Dispose(bool disposing)
        {
if (disposing && (components != null))
            {
                components.Dispose();
            }
base.Dispose(disposing);
        }

#region Windows 窗体设计器生成的代码

/// <summary>
/// 设计器支持所需的方法 - 不要
/// 使用代码编辑器修改此方法的内容。
/// </summary>
private void InitializeComponent()
        {
this.btn1 = new System.Windows.Forms.Button();
this.btn2 = new System.Windows.Forms.Button();
this.btn3 = new System.Windows.Forms.Button();
this.lblResult = new System.Windows.Forms.Label();
this.btn4 = new System.Windows.Forms.Button();
this.btn4Abort = new System.Windows.Forms.Button();
this.SuspendLayout();
// 
// btn1
// 
this.btn1.Location = new System.Drawing.Point(24, 99);
this.btn1.Name = "btn1";
this.btn1.Size = new System.Drawing.Size(141, 44);
this.btn1.TabIndex = 0;
this.btn1.Text = "创建线程并带参数传值1";
this.btn1.UseVisualStyleBackColor = true;
this.btn1.Click += new System.EventHandler(this.btn1_Click);
// 
// btn2
// 
this.btn2.Location = new System.Drawing.Point(24, 174);
this.btn2.Name = "btn2";
this.btn2.Size = new System.Drawing.Size(141, 39);
this.btn2.TabIndex = 1;
this.btn2.Text = "创建线程并带参数传值2";
this.btn2.UseVisualStyleBackColor = true;
this.btn2.Click += new System.EventHandler(this.btn2_Click);
// 
// btn3
// 
this.btn3.Location = new System.Drawing.Point(211, 174);
this.btn3.Name = "btn3";
this.btn3.Size = new System.Drawing.Size(131, 39);
this.btn3.TabIndex = 2;
this.btn3.Text = "通过线程池创建线程3";
this.btn3.UseVisualStyleBackColor = true;
this.btn3.Click += new System.EventHandler(this.btn3_Click);
// 
// lblResult
// 
this.lblResult.AutoSize = true;
this.lblResult.Location = new System.Drawing.Point(236, 115);
this.lblResult.Name = "lblResult";
this.lblResult.Size = new System.Drawing.Size(41, 12);
this.lblResult.TabIndex = 3;
this.lblResult.Text = "label1";
// 
// btn4
// 
this.btn4.Location = new System.Drawing.Point(211, 236);
this.btn4.Name = "btn4";
this.btn4.Size = new System.Drawing.Size(150, 44);
this.btn4.TabIndex = 4;
this.btn4.Text = "使用BackgroundWorker 4";
this.btn4.UseVisualStyleBackColor = true;
this.btn4.Click += new System.EventHandler(this.btn4_Click);
// 
// btn4Abort
// 
this.btn4Abort.Location = new System.Drawing.Point(211, 286);
this.btn4Abort.Name = "btn4Abort";
this.btn4Abort.Size = new System.Drawing.Size(150, 44);
this.btn4Abort.TabIndex = 5;
this.btn4Abort.Text = "4 取消当前操作";
this.btn4Abort.UseVisualStyleBackColor = true;
this.btn4Abort.Click += new System.EventHandler(this.btn4Abort_Click);
// 
// Form1
// 
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(399, 339);
this.Controls.Add(this.btn4Abort);
this.Controls.Add(this.btn4);
this.Controls.Add(this.lblResult);
this.Controls.Add(this.btn3);
this.Controls.Add(this.btn2);
this.Controls.Add(this.btn1);
this.Name = "Form1";
this.Text = "Form1";
this.ResumeLayout(false);
this.PerformLayout();

        }

#endregion

private System.Windows.Forms.Button btn1;
private System.Windows.Forms.Button btn2;
private System.Windows.Forms.Button btn3;
private System.Windows.Forms.Label lblResult;
private System.Windows.Forms.Button btn4;
private System.Windows.Forms.Button btn4Abort;
    }
}

 
      
 
     
 
    
 
   
 
   
 
   
 
   
 
    
 
    
 
    
 
   
 
  
 
  

    posted on 
   2014-03-05 23:34  
   v.e.n.u.s 阅读( 
   ...) 评论( 
   ...) 
    编辑 
   收藏 
  
 
 
 

 

转载于:https://www.cnblogs.com/jx270/p/3583614.html

                

        

        




    




    

      

        

            

              
                
                  baihuomeng2210
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
4. 线程代码创建（五种方法）

				
			

			

				

					小雨的博客
				

				

					07-07
					
					536
					
				

			

		

		

			
				
创建线程方法
方法一：通过继承Thread类的方法
public class ThreadDemo1 {
    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("我是一个线程");
        }
    }

    public static void main(String[] args) {
        Thr

			
		

	



                

              
                



	

		

			

				
					
Java创建线程的两种方法（附示例代码）

				
			

			

				

					Jason_Flash的博客
				

				

					05-12
					
					322
					
				

			

		

		

			
				
Java创建线程的两种方法方式一：继承Thread类方式二：实现Runnable接口
方式一：继承Thread类
主要步骤为：继承Thread类，重写run()方法，创建线程对象并调用start()方法开启线程。以下为示例代码：
public class TestThread1 extends Thread {
	public void run() {
		//重写run()方法
		for(int i = 0; i < 1000; i++) {
			System.out.println("打王者"

			
		

	



                


  
              

                


	

		

			

				
					
线程创建的三种方法与案例代码

				
			

			

				

					qq_41220595的博客
				

				

					05-07
					
					237
					
				

			

		

		

			
				
01线程简介
任务，进程。线程，多线程
Process（进程）与Thread（线程）
进程：执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
线程：一个进程可以包含若干个线程，一个进程在至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位

线程就是独立的执行路径
在程序运行时即使没有自己创建线程，后台也会有多个线程，如线程，gc线程
main（）称之为主线程，为系统...

			
		

	





	

		

			

				
					
C# BackgroundWorker使用总结

				
			

			

				

					qq_20097803的博客
				

				

					02-17
					
					170
					
				

			

		

		

			
				
查询了一下MSDN文档，其中微软就BackgroundWorker类的功能有这么一个描述（英文的，根据个人理解翻译）：BackgroundWorker类允许您在单独的线程上执行某个可能导致用户界面（UI）停止响应的耗时操作（比如文件下载数据库事务等），并且想要一个响应式的UI来反应当前耗时操作的进度。
可以看的出来，BackgroundWorker组件提供了一种执行异步操作（后台线程）的同时，并且...

			
		

	



		

			
		



	

		

			

				
					
python线程的几种创建方式详解

				
			

			

				

					09-18
				

			

		

		

			
				
主要介绍了python线程的几种创建方式详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

			
		

	





	

		

			

				
					
Java多线程中线程的两种创建方式及比较代码示例

				
			

			

				

					08-28
				

			

		

		

			
				
Java多线程中线程的两种创建方式及比较代码示例  Java多线程中线程的两种创建方式是指在Java编程语言中创建线程的两种方法：通过实现Runnable接口创建线程和通过继承Thread类创建线程。  1. 通过实现Runnable接口...

			
		

	





	

		

			

				
					
c#使用多线程的几种方式示例详解

				
			

			

				

					09-04
				

			

		

		

			
				
在实际开发中，选择哪种方式创建线程取决于具体的需求。如果只是简单地执行无参数的代码，第一种方式足够了。如果有参数传递需求，可以使用第二种或第四种方式。当需要更复杂的数据管理时，第三种方式的自定义线程类...

			
		

	





	

		

			

				
					
Java 实现多线程的几种方式汇总

				
			

			

				

					09-02
				

			

		

		

			
				
通过创建线程类的实例并调用`start()`方法来启动线程。这种方式简单直观，但因为Java不支持多重继承，所以如果该类还需要继承其他类，就无法使用这种方式。  2. **实现Runnable接口**：  如果不希望因为继承Thread而...

			
		

	





	

		

			

				
					
android代码示例常见几种

				
			

			

				

					10-25
				

			

		

		

			
				
在Android开发领域，掌握各种代码示例是提升技能的关键步骤。本资料包包含了七款不同的Android应用程序源代码，这些示例涵盖了Android开发的多个重要方面。让我们逐一解析这些知识点：  1. **活动（Activity）管理**...

			
		

	





	

		

			

				
					
C# 实例解析事件委托之EventHandler

				
			

			

				

					dotNET跨平台
				

				

					11-28
					
					585
					
				

			

		

		

			
				
概述  事件属于委托的一个子集，像我们平时界面上的鼠标点击按钮后响应事件、事件的发布和订阅等都需要用到委托.通过委托可以很好的实现类之间的解耦好。事件委托EventHandler的函数原型如下：delegate 表示这个个委托，事件委托没有返回值，有两个入参，sender是事件触发的对象，e是一个泛型的事件类型参数public delegate void EventHandler<TE...

			
		

	





	

		

			

				
					
3、线程通信EventHandler使用

				
			

			

				

					hanru723的博客
				

				

					08-06
					
					3602
					
				

			

		

		

			
				
作者：韩茹
公司：程序咖（北京）科技有限公司
鸿蒙巴士专栏作家

一、使用场景
EventHandler开发场景
EventHandler的主要功能是将InnerEvent事件或者Runnable任务投递到其他的线程进行处理，其使用的场景包括：

开发者需要将InnerEvent事件投递到新的线程，按照优先级和延时进行处理。投递时，EventHandler的优先级可在IMMEDIATE、HIGH、LOW、IDLE中选择，并设置合适的delayTime。
开发者需要将Runnable任务投递到新的线程，并按.

			
		

	





	

		

			

				
					
C# 中的EventHandler

				
			

			

				

					云海唯C的专栏
				

				

					01-31
					
					4919
					
				

			

		

		

			
				
占位置

			
		

	





	

		

			

				
					
C# 中的EventHandler实例详解

					
热门推荐

				
			

			

				

					kivetja的专栏
				

				

					09-03
					
					1万+
					
				

			

		

		

			
				
具体详情如下所示：


			1

			2

			3

			4

			5

			6

			7

			8

			9

			10

			11

			12

			13

			14

			15

			16

			17

			18

			19

			20

			21

			22

			23

			24

			25

			26

			27

			28

	...

			
		

	





	

		

			

				
					
c#中EventHandler

				
			

			

				

					yangdayededaye的博客
				

				

					02-09
					
					3803
					
				

			

		

		

			
				
namespaceTest
{
classWT
 
{
//定义一个委托
publicdelegatevoidEventHandler(stringa);
//为委托定义一个事件
publicstaticeventEventHandlerSendMessag

			
		

	





	

		

			

				
					
创建线程的4种方式以及实现的代码

				
			

			

				

					大房子爱生活的博客
				

				

					03-27
					
					1445
					
				

			

		

		

			
				
创建一个线程有四种方式：

继承Thread类创建线程
实现Runnable接口创建线程
使用Callable和Future创建线程
使用线程池例如用Executor框架

1.继承Thread类创建线程：
创建线程的步骤：

定义Thread类的子类，并重写该类的 run() 方法，该方法的方法体就是县城需要完成的任务，run() 方法也成为线程的执行体
创建Thread子类的实例，也就是创建了...

			
		

	





	

		

			

				
					
创建线程时，向新建的线程传参数

				
			

			

				

					Venus 的博客
				

				

					05-26
					
					3286
					
				

			

		

		

			
				
1、通过构造方法传递数据



public class MyThread extends Thread { 
    private String msg;

    public MyThread (String msg) { 
        this.msg = msg; 
    } 

    @Override   
    public void run() { 
        ...

			
		

	





	

		

			

				
					
C# EventHandler委托事件小结

				
			

			

				

					xjm1027932743的博客
				

				

					12-28
					
					9567
					
				

			

		

		

			
				
最近遇到一个委托的问题，+=这个符号，哇，真的是头皮发麻，以为是运算符，根本不知道是委托 -。-！！看下图： 
后面查了以后原来这种用法真的很普遍，我真是小白~~ 
资料中对C#委托的小清新解释：this.Activated += new EventHandler(Form1_Activated);
//Form1_Activated为方法名这个语句拆开为：this.Activated=先执行;

			
		

	





	

		

			

				
					
windows系统中创建线程常用哪几个函数，有什么区别？

				
			

			

				

					军说网事
				

				

					09-13
					
					3765
					
				

			

		

		

			
				
windows系统中创建线程常用哪几个函数？
在windows系统中创建线程的函数有：
CreadThread，AfxBeginThread，_beginthread，_beginthreadex。


他们的区别在于使用的场景不同。


CreateThread是Windows的API函数(SDK函数的标准形式,直截了当的创建方式，任何场合都可以使用)，提供操作系统级别的创建线程

			
		

	





	

		

			

				
					
java 中线程创建的几种方式

					
最新发布

				
			

			

				

					07-12
				

			

		

		

			
				
在Java中，有以下几种方式可以创建线程：

1. 继承Thread类：
   这是一种创建线程的最简单方式。通过继承Thread类，并重写其run()方法来定义线程的执行逻辑。然后可以创建Thread的实例并调用start()方法来启动线程。

示例代码：
```java
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的逻辑代码
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}
```

2. 实现Runnable接口：
   这是另一种创建线程的方式。通过实现Runnable接口，并实现其run()方法来定义线程的执行逻辑。然后可以创建Thread的实例，并将实现了Runnable接口的对象作为参数传递给Thread的构造方法来创建线程。

示例代码：
```java
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的逻辑代码
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}
```

3. 使用匿名内部类：
   如果线程逻辑比较简单，可以使用匿名内部类的方式来创建线程。

示例代码：
```java
public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程执行的逻辑代码
            }
        });
        thread.start();
    }
}
```

4. 使用线程池：
   线程池是一种管理线程的机制，通过线程池可以有效地重用线程，避免频繁地创建和销毁线程。Java提供了Executor框架来实现线程池的管理。

示例代码：
```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                // 线程执行的逻辑代码
            }
        });
        executorService.shutdown();
    }
}
```

通过以上几种方式，我们可以在Java中创建并启动线程，实现多线程的并发执行。根据具体的需求和场景，选择适合的方式来创建线程。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值