vb.net中如何定义线程内专用的变量

你把他设置为私有的，当然获取不了了，可以修改为public或者为该对象增加get，set方法

要么 使用全局变量.要么 在主线程中,通过全局变量,或者消息, 或者建立子线程传参, 总之凡是可行的交互方式都可以, 把主线程中变量的地址传给子线程. 即使用主线程写一个文件, 子线程去读这个文件, 这样的方法都是可以的.

ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。ThreadLocal 并不能替代同步机制，两者面向的问题领域不同。1：同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；2：而threadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享变量，这样当然不需要对多个线程进行同步了。import java.util.Random;public class ThreadSocpeShareData {static ThreadLocal<Integer> t = new ThreadLocal<Integer>();public static void main(String[] args) {for(int i=0;i<3;i++){new Thread(new Runnable() {

JMeter 变量作用域局限于所属线程。这样设计是经过深思熟虑的，目的是让测试线程能够独立运转。有时候用户可能需要在不同线程间（可能属于同一个线程组，也可能不属于同一个线程组）传递变量。 　　其中一种方法就是使用属性。属性为所有JMeter线程所共享，因此当某个线程设置一个属性后，其他线程就可以读取更新后的值。 　　如果存在大量数据需要在线程间传递，那么可以考虑使用文件。例如，测试人员可以在一个线程中使用监听器，保存响应到文件（Save Responses to a file ）或者 BeanShell PostProcessor 。而在另外一个线程中使用HTTP 采样器的“file: ”协议来读取文件，接着使用一个后置处理器或者BeanShell测试元件提取信息。 　　如果在测试启动前测试人员就能获得测试数据，那么最好将数据保存到文件中，使用CSV Data set读取。

方法很多，常用的是定义private变量。

其实线程内变量的定义非常非常简单！！！那就是不用定义！！！什么意思？就是说只需要在线程的sub程序中直接用那个变量就好！如果该变量有初始值，直接在sub内开头写入该变量的初始值就好

还是把Java基础好好看看吧；变量的生存周期、内存管理这两部分的知识点把握的不够啊；

我勒个汗 你不知道类模块么？

HashTable,每个线程用key往自己的value里面写东西,外界通过key访问每个线程写的东西,同理,dataTable也行啊,只要用标识区分开不同的row就可以了,或是每个线程一个dataTable,都放到dataSet中,通过表名就取到了。介绍：在一个程序中，这些独立运行的程序片断叫作“线程”，利用它编程的概念就叫作“多线程处理”。定义：每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。进程也可能是整个程序或者是部分程序的动态执行。线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。拓展：多线程块模型在每个进程里只有一个块而不是多个块。这单个块控制着多个线程而不是单个线程。这里不需要消息队列，因为所有的线程都是相同的块的一个部分，并且可以共享。这样的程序比单线程模型和STA的执行速度都要快，因为降低了系统的负载，因而可以优化来减少系统idle的时间。

把这个变量定义提取到线程外部, 线程通过引用持有这个变量, 这样就可以实现变量的共享, 这个时候就要注意线程同步的问题.

两个线程同时获取变量,获取之后.第一个线程++操作,然后进入睡眠.这时,第二个线程,也获取到了,做--操作.睡眠.第一个线程醒来打印的是做过2次运算的数据(++,--)所以是0第二线程也一样.这涉及到多线程安全问题.

定义全局变量是可以的，为空是因为你还没有给这个变量赋值就使用他了。解决方法在子线程获取数组并把值赋给全局变量，然后发送消息Message通知handler，最后在handler中接收通知并显示使用这个全局变量。

用setTimer()

Handler对象在主线程中创建，主线程中的消息队列由Handler对象来管理。由于在同一进程中的的线程共享内存，所以子线程可以获取到主线程中的handler对象。获取到handler，通过handle可以把Message插入到主线程消息队列中。主线程消息队列依次把队列中的Message对象交由主线程处理。

使用回调，变量改变。在主线程中对类C的实变量进行设置，然后输出变量开启子线程，通过构造函数传入变量，在子线程中改变变量的值子线程中调用主线程的静态方法传递数据给主线程说明子线程执行结束子线程结束后在主线程中查看变量已经发生改变。每个线程都有一个唯一标示符，来区分线程中的主次关系的说法, 线程唯一标示符，Thread.CurrentThread.ManagedThreadID。

可以啊，如果仅仅只是读取的话，就像从对象a里面读取对象b的变量一样操作就行了。如果涉及到修改的话就要考虑同步问题了。

局部变量不会受多线程影响成员变量会受到多线程影响多个线程调用的同一个对象的同一个方法：如果方法里无成员变量，不受任何影响如果方法里有成员变量，只有读操作，不受影响，存在赋值操作，有影响

可行，目前我能想到两个办法：1.你的第二个线程通过定时任务的类去启动，同时这个定时任务的类保存一个这个线程的引用，这样就可以改变这个线程的变量了。2.你的定时任务去设置一个全局的属性，然后这个线程一直监听这个属性，符合条件才执行。

1. 初始化的时候, 如果线程A执行完毕的时候, 线程B还没有运行(相信这个时候C还没有创建), 那么g_str肯定存的是初始化时读取的值.线程B要按button才调用, 如果一直没有按button, 就一直没有调用. 所以正常情况下你的程序都只有运行线程C, 你可以确认一下: a) 初始化后线程A, 有没有结束 b) 不按button, g_str的赋值是否正确? 如果不按button都不正确, 那么你的线程C的赋值本身就有问题. 注意看你怎么判断赋值成功, 或者赋值错了? 在什么时间点判断g_str的赋值出错.2. 你的情况线程B是随机发生的, 与线程C有冲突, 如果只是为了访问不冲突的话, 一般为g_str加个互斥就可以. 对g_str有特殊的使用点要求(对读取的时间点有要求)的话, 才要考虑同步的问题.

线程的执行顺序是未知的，这是由JVM的调度程序来决定的。在多线程共同使用一个相同的变量时，若没有同步就会产生数据不一致的情况。所以，最好使用同步，即synchronized关键字。

这个问题表达的不清晰，具体要在哪里访问呢？ 一般可以在继承线程的类下面先声明变量，再写一个get set方法。然后再线程中初始化。这样要访问的话直接get set就可以了。

是否用线程，要看你是否需要！如果你有需要并发处理的任务，可以开线程，如果像你说的这样，没有数据同步的需要，根据我做的测试的结果，反而会降低速度。先单独运行，然后运行test（下面代码的测试结果部分取决于机器本身）下面附上我的测试代码：ThreadApublic class ThreadA implements Runnable{ @Override public void run() { // TODO Auto-generated method stub long startTime = System.currentTimeMillis(); long number = 0L; for(int index = 0; index < Integer.MAX_VALUE; index++){ number += index; } long endTime = System.currentTimeMillis(); System.out.println(endTime - startTime); } public static void main(String[] args) { ThreadA a = new ThreadA(); a.run(); }}ThreadBpublic class ThreadB implements Runnable{ @Override public void run() { // TODO Auto-generated method stub long startTime = System.currentTimeMillis(); long number = 0L; for(int index = 0; index < Integer.MAX_VALUE; index++){ number += index; } long endTime = System.currentTimeMillis(); System.out.println(endTime - startTime); } public static void main(String[] args) { ThreadB b = new ThreadB(); b.run(); }}Testpublic class Test { public static void main(String[] args) { Thread a = new Thread(new ThreadA()); Thread b = new Thread(new ThreadB()); a.start(); b.start(); }}

线程的局部变量是无法互相调用的可以声明一些全局变量，也可以在堆中用new或malloc分配一些对象， 用于线程间相互访问，但要做一些线程同步措施，比如临界、信号之类的

我想问一下怎么实现啊，我也遇到这问题了

public class Demo{ public static void main(String[] args) { n=Integer.parseInt(args[0]); String l="lock"; System.out.println("n="+n); Thread a=new Thread() { public void run() { synchronized(l) { while(n>=0) { n++; System.out.println("n="+n); l.notify(); try { l.wait(); } catch(Exception e) { } } l.notify(); } } }; Thread b=new Thread() { public void run() { synchronized(l) { while(n>=0) { n-=2; System.out.println("n="+n); l.notify(); try { l.wait(); } catch(Exception e) { } } l.notify(); } } }; a.start(); b.start(); } static int n;}

不能 定义成全局变量

早在Java 1.2推出之时，Java平台中就引入了一个新的支持：java.lang.ThreadLocal，给我们在编写多线程程序时提供了一种新的选择。使用这个工具类可以很简洁地编写出优美的多线程程序，虽然ThreadLocal非常有用，但是似乎现在了解它、使用它的朋友还不多。 　　 ThreadLocal是什么 　　 ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是thread local variable（线程局部变量）。也许把它命名为ThreadLocalVar更加合适。线程局部变量（ThreadLocal）其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。线程局部变量并不是Java的新发明，在其它的一些语言编译器实现（如IBM XL FORTRAN）中，它在语言的层次提供了直接的支持。因为Java中没有提供在语言层次的直接支持，而是提供了一个ThreadLocal的类来提供支持，所以，在Java中编写线程局部变量的代码相对比较笨拙，这也许是线程局部变量没有在Java中得到很好的普及的一个原因吧。 　　 ThreadLocal的设计 　　 首先看看ThreadLocal的接口： 　　 　Object get() ; // 返回当前线程的线程局部变量副本 protected Object initialValue(); // 返回该线程局部变量的当前线程的初始值 　　　 void set(Object value); // 设置当前线程的线程局部变量副本的值 　　 ThreadLocal有3个方法，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()或者set(Object)时才执行，并且仅执行1次。ThreadLocal中的确实实现直接返回一个null： 　　protected Object initialValue() { return null; } 　　ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。比如下面的示例实现： 　　public class ThreadLocal 　　{ 　　 private Map values = Collections.synchronizedMap(new HashMap()); 　　 public Object get() 　　 { 　　 Thread curThread = Thread.currentThread(); 　　 Object o = values.get(curThread); 　　 if (o == null && !values.containsKey(curThread)) 　　 { 　　　 o = initialValue(); 　　　 values.put(curThread, o); 　　 } 　　 return o; 　　 } 　　 public void set(Object newValue) 　　 { 　　 values.put(Thread.currentThread(), newValue); 　　 } 　　 public Object initialValue() 　　 { 　　 return null; 　　 } 　　} 　　当然，这并不是一个工业强度的实现，但JDK中的ThreadLocal的实现总体思路也类似于此。 　　 ThreadLocal的使用 　　 如果希望线程局部变量初始化其它值，那么需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，比如下面的例子，SerialNum类为每一个类分配一个序号： 　　public class SerialNum 　　{ 　　 // The next serial number to be assigned 　　 private static int nextSerialNum = 0; 　　 private static ThreadLocal serialNum = new ThreadLocal() 　　 { 　　 protected synchronized Object initialValue() 　　 { 　　　 return new Integer(nextSerialNum++); 　　 } 　　 }; 　　 public static int get() 　　 { 　　 return ((Integer) (serialNum.get())).intValue(); 　　 } 　　} 　　SerialNum类的使用将非常地简单，因为get()方法是static的，所以在需要获取当前线程的序号时，简单地调用： 　　int serial = SerialNum.get(); 　　即可。 　　 在线程是活动的并且ThreadLocal对象是可访问的时，该线程就持有一个到该线程局部变量副本的隐含引用，当该线程运行结束后，该线程拥有的所以线程局部变量的副本都将失效，并等待垃圾收集器收集。 　　 ThreadLocal与其它同步机制的比较 　　 ThreadLocal和其它同步机制相比有什么优势呢？ThreadLocal和其它所有的同步机制都是为了解决多线程中的对同一变量的访问冲突，在普通的同步机制中，是通过对象加锁来实现多个线程对同一变量的安全访问的。这时该变量是多个线程共享的，使用这种同步机制需要很细致地分析在什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放该对象的锁等等很多。所有这些都是因为多个线程共享了资源造成的。ThreadLocal就从另一个角度来解决多线程的并发访问，ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal，或者把该对象的特定于线程的状态封装进ThreadLocal。 　　 由于ThreadLocal中可以持有任何类型的对象，所以使用ThreadLocal get当前线程的值是需要进行强制类型转换。但随着新的Java版本（1.5）将模版的引入，新的支持模版参数的ThreadLocal类将从中受益。也可以减少强制类型转换，并将一些错误检查提前到了编译期，将一定程度地简化ThreadLocal的使用。 　　 总结 　　 当然ThreadLocal并不能替代同步机制，两者面向的问题领域不同。同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源（变量），这样当然不需要对多个线程进行同步了。所以，如果你需要进行多个线程之间进行通信，则使用同步机制；如果需要隔离多个线程之间的共享冲突，可以使用ThreadLocal，这将极大地简化你的程序，使程序更加易读、简洁。

为何不设置两个断点来调试呢，一个在SendMessage后面::EnterCriticalSection(&m_css); 一个在你的主线程等待那里-----------华丽的分割线---------------实际上你根本不用那样做，你可以设置一个event，在子线程完成时激活这个事件，主线程等待这个事件就好了

定义全局变量是可以的，为空是因为你还没有给这个变量赋值就使用他了。解决方法在子线程获取数组并把值赋给全局变量，然后发送消息Message通知handler，最后在handler中接收通知并显示使用这个全局变量。

现在我写的源代码如下：#include <stdio.h>#include <pthread.h>typedef struct{char test_no1[12];char test_no2[20];short test_length;} tsm_info_def;void *SendSM(void *arg){char No1[12];char No2[20];int Length;tsm_info_def *pSmInfo=(tsm_info_def *)arg;strcpy(No1,pSmInfo->test_no1);strcpy(No2,pSmInfo->test_no2);Length = pSmInfo->test_length;printf("%s%s%d ",No1,No2,Length);}int main(void){pthread_t id;int ret,i;char tmpstr[20];tsm_info_def SmInfo;strcpy(SmInfo.test_no1,"12345678901");strcpy(SmInfo.test_no2,"测试的内容");pSmInfo->test_length = 10;for(i=0;i<3;i++){sprintf(str,"%d",i);strcat(SmInfo.test_no2,str);ret=pthread_create(&id,NULL,SendSM,(void *)&SmInfo);if(ret!=0){fprintf(stderr,"Create pthread error! ");}}pthread_join(id,NULL);return (0);}

可以的。- -

线程中的局部变量不需要同步；线程内操作的,同时线程外需要用到的,需要同步!

使用回调，变量改变。在主线程中对类C的实变量进行设置，然后输出变量开启子线程，通过构造函数传入变量，在子线程中改变变量的值子线程中调用主线程的静态方法传递数据给主线程说明子线程执行结束子线程结束后在主线程中查看变量已经发生改变。每个线程都有一个唯一标示符，来区分线程中的主次关系的说法, 线程唯一标示符，Thread.CurrentThread.ManagedThreadID。

用全局变量

想办法获得CRubberbandView的一个指针，用指针调用那个函数如果你那个View已经注册过，且处于active状态，可用//#include"mainframe.h"//#inlcude"ruberandview.h"CMainFrame*pMain=(CMainFrame*)AfxGetApp()->m_pMainWnd;CRubberbandView*pView=(CRubberbandView*)pMain->GetActiveView();pView->bresenham();

局部变量不会受多线程影响成员变量会受到多线程影响多个线程调用的同一个对象的同一个方法：如果方法里无成员变量，不受任何影响如果方法里有成员变量，只有读操作，不受影响，存在赋值操作，有影响

是静态类型吗？两个线程使用的对象是同一个实例吗？可以输出一下你的类的hashcode。

楼主程序中有些小错误，我改了下，程序能实现你说的功能#include <qthread.h>#include <qapplication.h>#include <qwidget.h>#include <STDIO.H>class Thread:public QThread{private: int a;public: void setA(int i){a=i;}void run(){printf("%d",a);}};class A:public QWidget{public: A( QWidget *parent = 0 );private: Thread th;public: void fuck();};A::A( QWidget *parent ) :QWidget(parent){}void A::fuck(){ th.setA(5); th.start();}int main(int argc, char **argv){ QApplication q(argc, argv); A a; a.fuck(); a.show(); return q.exec();}

java是面向对象语言，一切成员都会封装在一个类中，定义成private是为了更好地隐藏，对外暴露的是setter和getter方法，所以可以通过setter设置值，getter来取值，达到模块隐藏的目的。

1.python中数据类型，int,float,复数，字符，元组，做全局变量时需要在函数里面用global申明变量，才能对变量进行操作。 而，对象，列表，词典，不需要声明，直接就是全局的。 2.线程锁mutex=threading.Lock() 创建后就是全局的。线程调用函数可以直接在函数中使用。 mutex.acquire()开启锁 mutex=release()关闭锁 要注意，死锁的情况发生。 注意运行效率的变化: 正常1秒，完成56997921 加锁之后，1秒只运行了531187，相差10倍多。 3.继承.threading.Thread的类，无法调用__init__函数，无法在创建对象时初始化新建的属性。 4.线程在cpu的执行，有随机性 5. 新建线程时，需要传参数时，args是一个元组，如果只有一个参数，一定后面要加一个,符号。不能只有一个参数否则线程会报创建参数错误。threading.Thread(target=fuc,args=(arg,))

多线程要么集成Thread类 要么实现Runnable 接口 入口都是public void run(){} 如果需要一个完善的可以做一个线程池.

public int _CurrentThread;//form1_load中的，启动线程的代码在这里。private void Form1_Load(object sender, EventArgs e){ //设置最大线程数int MaxThread = 5;//获取需要完成的任务列表OleDbConnection AccessConn = AccessModule.Conn("D:\Flying Co\flying.mdb");string sql = "select * from ty_task where bay_flag=" + false + " order by bay_id asc";OleDbCommand comm = new OleDbCommand(sql, AccessConn);OleDbDataReader list = comm.ExecuteReader();while (list.Read()){ContentParse Spider = new ContentParse();//如果当前活动线程超过最大线程数，线程休眠if (Spider.CurrentThread> MaxThread){Thread.Sleep(2000);}else{//initSpider.Url = list["bay_task"].ToString();//启动一个线程Thread SpiderThread = new Thread(new ThreadStart(Spider.execute));SpiderThread.Start();MessageBox.Show(Spider.CurrentThread.ToString());//任务设置为已处理sql = "update ty_task set bay_flag=" + true + " where bay_id=" + list["bay_id"].ToString();AccessModule.Execute(AccessConn, sql);}}list.Close();AccessModule.DisConn(AccessConn);} //线程启动的是这个类的方法class ContentParse{ private string _Url;//设置任务参数public string Url{set{_task = value;}}public void execute(){//活动线程数加1Interlocked.Increment(ref _CurrentThread);//中间处理任务的代码省略//该线程完成，活动线程减1Interlocked.Decrement(ref _CurrentThread);}我现在纠结的就是这个Interlocked.Increment(ref _CurrentThread);应该是开一个线程就要加1的对吧？ 但是我在form1中间用 MessageBox.Show(Spider.CurrentThread.ToString());，总是0噢

不太明白“主线程每隔一段时间去访问这个static变量，取到值以后，将该变量清空”的用意，目的是主线程通知子线程变量已经被取走了吗？

环境变量可以休改啊，但只有在该环境下才是你修改的值，到了其它线程或主程序中就等于改变了环境。如果要传值，可以用全局变量。

那就new 1000个线程呗 。。。

100次应该看不出多线程的情况

你要做的只是打印list的内容，而不是修改list的内容，所以这里不需要加锁，直接打印就行了。

你好，楼主是说block级的同步吗？CUDA没有提供这样的函数，因为一是这种操作太耗时间，二是凡是这种操作都可以以其他方式解决。CUDA提供了一下两个同步函数：__syncthreads(); 用来同步每个block内的线程，用于kernel当中。cudaDeviceSyncronize(); 用来同步设备上所有之前的操作。在调用cudaStream或者多个GPU的时候需要用到这个函数来保证每个stream或每个GPU运行到同一点。

我认为是由于++或者+=都不是原子操作，实际执行分三步：1.读值，2.+1，3.赋值，假设值为1，线程1可能刚刚把值读了（此时记住1），线程2就开始执行一套操作，成功+1（此时值为2），然后线程1还是保持原来的记忆1，+1后，进行赋值，最终值还是2。相当于你加了2次，但结果只增加1。知识点应该是多线程与原子操作