跨線程訪問控制項c
① C# Timer lock 多線程 的幾點疑問。
您好..關於您的問題.
1>
第一個關於Forms.timer的描述正確
System.Windows.Forms.Timer是使用得比較多的Timer，Timer Start之後定時（按設定的Interval）調用掛接在Tick事件上的EvnetHandler。在這種Timer的EventHandler中可 以直接獲取和修改UI元素而不會出現問題--因為這種Timer實際上就是在UI線程自身上進行調用的。也正是因為這個原因，導致了在Timer的 EventHandler裡面進行長時間的阻塞調用，將會阻塞界面響應的後果。
第二個關於Lock
如果另外的線程並未使用到LOCK的對象.則雙方之間沒有任何阻塞,中段,等待的關系
2>Lock鎖其實指的是以某一個變數為准.
如果你的另外一個線程,使用到了LOCK的對象,那麼他會在LOCK代碼段內的代碼執行完畢後執行.
例如:
Lock(A)
{
//.....耗時10分鍾的操作
}
線程B
XXXX
X
XXXX
A=C
XXXXX
如果執行到了A=C
那麼下方的代碼將不會被執行.當前的運行邏輯等待到了A=C這句話上.
等待LOCK的10分鍾操作完畢後.繼續執行
所以.如果窗體主線程中有一段代碼被 lock ，那麼 Forms.Timer會將其中斷嗎？還是等待這段代碼執行完才執行其響應函數。
取決於你鎖定了什麼
例如你LOCK(THIS)
因為this在winform中指當前窗體,所以你就鎖定了所有的THIS內的變數,控制項.集體等待.也就是.LOCK會鎖定對應變數/對象的繼承關系
3>靜態的有什麼好處，不是靜態的有什麼影響？
請看第二問的答案.如果你看明白後你就會明白.
如果你LOCK的始終是一個new出來的對象.那麼大家其實就等於沒有鎖.
因為我並沒有使用你的對象.所以我不阻塞
4>跨線程調用窗體中的控制項會出現線程安全問題，但我發現，跨線程設置狀態欄上的 label的文本屬性是沒有問題的，是 label的特殊，還是狀態欄的特殊，還是怎麼回事？
狀態欄的UI線程其實是他的父線程所屬的.
當你要看某個控制項是否符合線程 安全的情況.查閱對應對象是否存在INVOKE即可.
其實您的第4個問題我暫時並不敢給您肯定的回答.您的賦值代碼我並不清楚.
按照理論來說.他並不特殊.雖然他沒有對應invoke.
您用的是STATEXXXXX.LABEL控制項吧.
如果還有其他問題.您可以繼續追問.
望採納.
Ths.
Ben.Lampson
② C# 在某個線程上創建的控制項不能成為在另一個線程上創建的控制項的父級
哈哈，這個問題我也碰到過的！
MSDN上的解釋說.NETFramework2.0前的時代可以通過子線程在父線程創建控制項，當時你上述的代碼是正確的。
但是使用線程操作常常會是復雜而且危險的，所以微軟在.NETFramework2.0及以後版本都對線程的操作進行了限制。
像你的代碼流程應該是這樣的：
首先在form1的窗體載入中新建了一個Class1對象並將本身的引用傳遞進入其構造函數，然後在Class1的構造函數中創建一個線程。該線程所代理的方法事件是本類中的一個add方法。而add方法的內容則是在form1上放一個textbox.
然而這個流程你需要注意的有幾個問題：
1.哪個是主線程？所謂主線程是第一個啟動的線程，是從main開始的。form1的這個窗體是由主線程創建的。
2.Thread t的線程是什麼？t是由主線程創建的，t的操作內容是在由主線程創建的窗體上放一個textbox.
也就是說，t的操作是跨線程的窗體操作。雖然樓主把 設置成了false,但是還存在在某個線程上創建的控制項不能成為在另一個線程上創建的控制項的父級這個異常。
這個問題說實話我也不懂，不好說什麼。可能微軟禁止了一個線程在另一個線程上添加自己的控制項，因為這種做法著實不安全。
至於解決辦法：
1.不要線程，只在一個主線程中操作。此時你在class1中添加控制項也好，在form1中寫個方法來添加控制項也好，都是可行的。
2.通過代理來實現。在對form1對象的操作中
if(form1.InvokeRequired)
{
form1.Invoke(d);//d為在主線程中創建的代理引用
//d所代理的方法應該是添加控制項的內容
}
else
{
form1.Controls.add(textBox1);//直接使用
}
//代碼
class Class1
{
Form1 f1;
TextBox textBox1;
delegate void addDelegate();
addDelegate d;
public Class1(Form1 f1)
{
this.f1 = f1;
d=new addDelegate(f1.add());//此處的add是在form1中的方法
Thread t = new Thread(new ThreadStart(add));
t.Start();
}
public void add()
{
if(f1.InvokeRequired)
{
f1.Invoke(d); //使用代理
}
else
{
f1.Controls.add(new TextBox());//...直接調用
}
}
}
樓主可以在MSDN上查找 「線程處理[windows窗體]」,上面有很詳細的描述。
在下也是菜鳥一隻，有錯誤請樓下的朋友指出
③ C#內置的幾種委託詳解，lambda表達式的演變
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 跨線程訪問
{
class Program
{
static void Main(string[] args)
{
Action A = delegate
{
Console.WriteLine("I am A ");
};
Action<int> B = delegate(int i)
{
Console.WriteLine("I am B " + i);
};
Action<int, string> C = delegate(int i, string s)
{
Console.WriteLine("I am C " + i + " " + s);
};
Action<int, string, int> D = delegate(int i, string s, int j)
{
Console.WriteLine("I am D " + i + " " + s + " " + j);
};
Action<int, string, int, string> E = delegate(int i, string s, int j, string t)
{
Console.WriteLine("I am E " + i + " " + s + " " + j + " " + t);
};
/*Action A = () =>
{
Console.WriteLine("I'm A ");
};
Action<int> B = (i) =>
{
Console.WriteLine("I'm B " + i);
};
Action<int, string>C = (i, s) =>
{
Console.WriteLine("I'm C " + i + " " + s);
};
Action<int, string, int> D = (i, s, j) =>
{
Console.WriteLine("I'm D " + i + " " + s + " " + j);
};
Action<int, string, int, string> E = (i, s, j, t) =>
{
Console.WriteLine("I'm E " + i + " " + s + " " + j + " " + t);
};*/
A();
B(1);
C(1, "a");
D(1, "a", 2);
E(1, "a", 2, "b");
Console.ReadKey();
}
}
}
我們需要掌握理解好匿名委託，因為，在我們的跨線程訪問控制項中，一旦我們在非UI線程訪問控制項就會出錯，這是我們利用匿名委託就能解決好問題。
④ VCL中的控制項直接支持多線程嗎
因為你寫的程序是獨占模式，而不是應用線程。瑞星殺毒時，點擊別的菜單仍然有反應，是因是殺毒過程是另一個線程，WIN 98/NT/2000/XP 是個多任務操作系統，也就是：一個進程可以劃分為多個線程，每個線程輪流佔用CPU 運行時間和資源，或者說，把CPU時間劃成片，每個片分給不同的線程，這樣，每個線程輪流的「掛起」和「喚醒」，由於時間片很小，給人的感覺是同時運行的。
下面是自己找的一些資料，你參考一下：
多線程帶來如下好處：（自己閱讀）
1）避免瓶頸；
2）並行操作；
3）提高效率；
在多線程中，通過優先順序管理，可以使重要的程序優先操作，提高了
任務管理的靈活性。
另一方面，在多CPU 系統中，可以把不同的線程在不同的CPU 中執行，
真正做到同時處理多任務（Win 98 只是模擬的，而Win/NT/2000是真正的
多CPU同時操作）。
多線程的兩個概念：
1） 進程：也稱任務，程序載入內存，並分配資源，稱為「一個進程
」。注意：進程本身並不一定要正在執行。進程由以下幾部分組成：
a>一個私有的地址空間，它是進程可以使用的一組虛擬內存地址空間；
b>程序的相關代碼、數據源；
c>系統資源，比如操作系統同步對象等；
d>至少包含一個線程（主線程）；
2） 線程：是程序的執行單位（線程本身並不包括程序代碼，真正擁
有代碼的是進程），每個進程至少包括一個線程，稱為主線程，一個進程
如果有多個線程，就可以共享同一進程的資源，並可以並發執行。
線程是進程的一個執行單元，是操作系統分配CPU 時間的基本實體，
線程主要由如下兩部分組成：
a>數據結構；
b>CPU 寄存器和堆棧；
一個進程中的線程，可以獨立運行，也可以控制另一個線程的運行。
請注意：
多線程不能濫用，書上提到了多線程的幾個缺點（自閱）。
2-2 Tthread 對象
雖然Windows 提供了比較多的多線程設計的API 函數，但是直接使用
API 函數一方面極其不方便，而且使用不當還容易出錯。為解決這個問題，
Borland 公司率先推出了一種Tthread 對象，來解決多線程設計上的困難，
簡化了多線程問題的處理。
應該注意，Tthread 對象是沒有實例的，它和界面的交流，主要依靠
主窗體（主VCL線程），這和其他對象使用上有些區別。
一、Tthread 對象的主要方法
構造線程：
constructor Create(CreateSuspended:boolean)
其中：CreateSuspended=true 構造但不喚醒
false 構造的同時即喚醒
也可以用如下方法
inheried Create(CreateSuspended:boolean)
掛起線程：
suspend
（把線程掛起的次數加一）
喚醒線程：
resume
（注意：注意這個屬性是把線程掛起的次數減一，當次數為0 時，
即喚醒。也就是說，線程掛起多少次，喚醒也需要多少次。同時掛起
的時候將保持線程的地址指針不變，所以線程掛起後再喚醒，將從掛
起的地方開始運行）
析構（清除線程所佔用的內存）：
destroy
終止線程（後面會具體討論）:
Terminate
二、線程應用的簡單例子：
下面通過一個例子說明上述方法的應用。我們知道，循環是獨占
性最強的運行方式之一，現在希望建立兩個線程對象，實現循環的並
行運行。具體方法如下：
File---New---Thread Object
這就自動在主Form中建立了一個線程單元（在對話框里寫上線程名
字），默認的名字是Unit2。同樣方法建立第二個線程單元Unit3。
要注意的是：Unit2和Unit3中有一個給定的過程：
procere Object.Execute;
begin
end;
其中的程序是線程喚醒後自動執行的程序，也可以在裡面調用其
他自定義的過程和函數。這個過程的結束，意味著線程程序的結束。
為了構造線程，在interface的Type區，定義一個構造過程：
type
Object = class(TThread) //自動給出的，也可以直接改
private
protected
procere Execute; override;
public
constructor create; //自己寫的
並且在implementation區域寫上：
constructor Object.create;
begin
inherited create(true);
end
其中Object 為線程對象的名字。所以這么寫，是希望在主Form中
調用這個構造過程。
Create()的參數用True，表明構造出的線程為掛起狀態。
注意一下，在同一個線程對象里，如果兩次構造，將產生兩個獨立
的線程，不但運行是獨立的，而且使用線程的局部變數也是獨立的。但
這里為了簡化問題，還是建立了兩個獨立的線程對象，而且兩個循環數
是不同的，在並行運算時容易判斷出是兩個不同的程序在運行。
假定我們給兩個線程對象起的名字是：
mymath1
mymath2
這樣在Unit1，應該作如下聲明：
implementation
uses unit2,unit3;
var thread1:mymath1;
thread2:mymath2;
這樣在主線程，將可以通過這兩個線程變數調用對應的線程方法。
在主線程區構造線程的方法是：
thread1:=mymath1.create;
thread2:=mymath2.create;
掛起：
thread1.suspend;
thread2.suspend;
喚醒：
thread1.resume;
thread2.resume;
析構：
thread1.destroy;
thread2.destroy;
這里需要說明的是，由於線程單元需要調用Form的Edit控制項（對象），
可以採用兩種方法：
1） 在線程單元定義一個TEdit對象，例如
edit4:Tedit;
在Execute過程內直接引用
但在Unit1中一定要在FormCreate過程里作一個賦值：
procere TForm1.FormCreate(Sender: TObject);
begin
thread1.edit4:=edit1;
end;
這樣，就把第一線程的edit4與Form上的edit1聯系來。
2）在第二個線程中首先聲明調用Unti1，也就是要加上
Uses Unit1;
這樣就可以在該線程單元直接調用主Form的控制項了，比如在Unit3中
可以寫：
form1.edit2.text:=inttostr(i)
了解了這些基本規則，就可以寫出比較復雜的多線程程序了。
還有一點要說明的，默認生成的線程單元，調用的單元只有一個：
Uses Classes;
這樣，往往很多函數和對象在線程單元里不能使用，所以在必要時，
應該根據需要User相應的單元，這個常式為了簡單，把大部分常用的單
元都拷過去了，這並不是推薦的辦法，因為這樣一來會使程序的垃圾過
多，所以，一般要用什麼拷什麼。
三、常用的API 函數
在處理多線程問題的時候,也經常用到Windows提供的API 函數，需
要說明的是，Tthread 對象內部封裝的方法，其實主要也是調用API 函
數，但是，考慮更全面，更安全。而直接調用API 函數，往往會因為運
用不當，出現一些不應有的錯誤。所以，我個人以為，只要用Tthread
對象的方法能解決的，就不要直接調用API 函數，API 函數只應該在用
在Tthread 對象方法解決不了的時候。
例如Tthread 對象方法內部調用API 函數的時候，一般使用推薦的
默認值，但需要更精細的控制時，就可以直接使用API 函數。
其實，Tthread 對象方法已經受到了大多數程序設計者的認可，比
如，原來VB是不具備直接處理多線程的能力的，但是，現在VB.Net就宣
稱，它具備了簡單處理多線程問題的能力，這就很說明問題。
下面簡單介紹幾種API 函數，為了清晰方便，這里著重在於說明，
函數正確的描述可以自己閱讀書上的例子和手冊：
構建線程：
CreateThread(參數1，--安全屬性（一般=Nil，默認安全屬性）
參數2，--線程堆棧尺寸（一般=0，與主線程相同長
度，而且可以根據需要自動變化）
參數3，--指向函數名指針，@函數名，這個參數十
分重要，不正確將無法調用成功。
參數4，--用戶需要向線程傳遞的參數，是一個指向
結構的指針，不需傳遞參數時，為Nil。
參數5）--傳入與線程有關的一些參數，例如：
CREATE_SUSPENDED 創建一個掛起的線程；
0 創建後立即激活。
書上有這個函數應用的十分清晰的例子，可以自己閱讀。
一般並不推薦使用 CreateTheard函數，而推薦使用RTL 庫里的
System單元中定義的 BeginTheard函數，因為這除了能創建一個線程
和一個入口函數以外，還增加了幾項保護措施，具體的請參閱書上的
第10頁說明。
對應suspend（掛起）和resume（喚醒）的兩個API 函數為：
Function SuspendThread(hThread:Thandle):DWORD;
Function ResumeThread（hThread:Thandle):DWORD;
其中，Thandle被要求控制線程的句柄，函數調用成功，返回掛
起的次數，調用不成功。則返回0xFFFFFFFF。
四、線程的終止和退出：
1)自動退出：
一個線程從Execute()過程中退出，即意味著線程的終止，此時
將調用Windows的ExitThread()函數來清除線程所佔用的堆棧。
如果線程對象的 FreeOnTerminate 屬性設為True，則線程對象
將自動刪除，並釋放線程所佔用的資源。
這是消除線程對象最簡單的辦法。
2)受控退出：
利用線程對象的Terminate屬性，可以由進程或者由其他線程式控制
制線程的退出。只需要簡單的調用該線程的Terminate方法，並設直
線程對象的Terminate屬性為True。
在線程中，應該不斷監視Terminate的值，一旦發現為True，則
退出，例如在Execute()過程中可以這樣寫：
While not Terminate do
begin
........
end;
3)退出的API 函數：
關於線程退出的API 函數聲明如下：code
Function TerminateThread(hThread:Thandle;dwExitCode:DWORD);
不過，這個函數會使代碼立刻終止，而不管程序中有沒有
try....finally
機制，可能會導致錯誤，不到萬不得已，最好不要使用。
4) 利用掛起線程的方法（suspend）
利用掛起線程的suspend方法，後面跟個Free，也可以釋放線程，
例如：
thread1.suspend; //掛起
thread2.free; //釋放
書上有相應的例子。
五、 線程的優先順序：
在多線程的情況下，一般要根據線程執行任務的重要性，給線程
適當的優先順序，一般如果量的線程同時申請CPU 時間，優先順序高的線
程優先。
在Windows下，給線程的優先順序分為30級，而Delphi中Tthread
對象相對簡單的把優先順序分為七級。也就是在Tthread中聲明了一個
枚舉類型TTthreadPriority:
type
TTthreadPriority(tpidle,tpLowest,tpLower,tpNormal,
tpHight,tpHighest,tpTimecrital)
分別對應的是最低（系統空閑時有效，-15），較低（-2），低
（-1），正常（普通0），高（1），較高（2），最高（15）。
其中tpidle和tpTimecrital有些特殊，具體情況請閱讀書上有
關內容。
設置優先順序可使用thread對象的priority屬性：
threadObject.priority:=Tthreadpriority(級別);
這里給出了一個演示多線程優先順序的實例：
2-3 在資料庫中使用多線程
一）使用ADO模式
由於Delphi 6.0的ADO 數據源控制項內置了多線程能力，所以，在
ADO模式下，使用多線程不需要做更多的工作。用兩個ADOTable控制項，
分別連到兩個資料庫，並且分別通過DataSource控制項，與數據幫定控
件聯系就可以了，這樣就可以實現前後台處理資料庫問題。
二）使用BDE模式和Tseeion對象
如果需要使用BDE 模式，那麼多線程使用資料庫，就要考慮Session
的問題。在單線程時，每個數據源的建立就自動生成一個Session，
這是這個數據源私有的關於資料庫信息的文件。但多線程時，必須統
一管理，所以在BDE 中專門提供了一個Tsession對象，它可以同時管理
不同的Databas數據源對象。
Databas數據源可以接受來自不同數據平台的資料庫。
資料庫1---databas(2)----table(Qurey)(3)---datasource
| |
| |
|--------- Tsession(1)
| |
| |
資料庫2---databas(2)----table(Qurey)(3)---datasource
方法：
1）Tsession
屬性：SessionName=名（自起）
Active=true （激活）
2）Database（可以有多個）
屬性：SessionName=Tsession名
Dataname=名（自起，作為Table的標識）
AliasName=資料庫別名
Connected=True （激活）
3）Table或Qurey
屬性：SessionName=Tsession名（不要用默認值）
DatabaseName=如果前面起了名，這里就會出現Database
的名字。
Tablename=表名
Active=true （激活）
以後比如加入Datasoucre和其他一樣，這樣就可以構造兩個前後
台處理的資料庫管理系統了。
2-4 多線程的同步機制
同步機制，實際上是事件驅動機制，意思是讓線程平時處於「休
眠」狀態，除非發生某個事件才觸發。
例如一個拷貝文件，拷貝線程完成一個程序塊後，再喚醒進程條
線程做一個格的填充。
研究多線程的同步機制的必要性在於，多線程同步工作時，如果
同時調用相同的資源，就可能會出現問題，一般讀出是不會有問題的，
但是，如果寫入（全局變數、資料庫），就會發生沖突，甚至產生死
鎖和競爭問題。
一、使用Synchronize方法
這個方法用於訪問VCL 主線程所管理的資源，其方法的應用是：
第一步：把訪問主窗口（或主窗口控制項資源）的代碼放到線程的
一個方法中；
第二步：是在線程對象的Execute方法中，通過Synchronize方法
使用該方法。
實例：
procere Theater.Execute;
begin
Synchronize(update);
end;
procere Theater.update;
begin
.........
end;
這里通過 Synchronize使線程方法update同步。
二、使用VCL類的Look方法
在Delphi的IDE提供的構件中，有一些對象內部提供了線程的同
步機制，工作線程可以直接使用這些控制項，比如：Tfont，Tpen，
TBitmap，TMetafile，Ticon等。另外，一個很重要的控制項對象叫
TCanvas，提供了一個Lock方法用於線程的同步，當一個線程使用此
控制項對象的時候，首先調用這個對象的Lock方法，然後對這個控制項
進行操作，完畢後再調用Unlock方法，釋放對控間的控制權。
例如：
CanversObject.look;
try
畫圖
finally
CanversObject.unlock;
end;
{使用這個保護機制,保證不論有沒有異常，unlock都會被執行
否則很可能會發生死鎖。在多線程設計的時候，應該很注意發生死
鎖的問題}
三、Waitfor方法
當一個線程應該等待另一個線程結束時，可以調用Waitfor方法。
這個方法屬於等待線程對象，Waitfor方法的原型如下:
Function Waitfor(Const Astring:string):string;
比如在前面最基本的線程的例子中，喚醒線程的語句中加上
thread1.resume;
thread1.waitfor;
thread2.resume;
那麼所有的線程都必須等待thread1運行完畢後才能運行，其中
包括主線程，可以預想，由於thread1調用了主窗體的Edit控制項，那
么，在thread1運行中間，Edie1也不會顯示。
這就告訴我們，這樣的代碼是不能作為主線程的一部分的，如果
與主窗體連接的線程內等待另一個線程結束，而另一個線程又要等待
訪問用戶界面，就可能是程序陷於死鎖。
這點在應用的時候要謹慎。
⑤ 非UI線程中如何改變UI控制項屬性
在.NET中如需在非UI線程中改變UI控制項屬性時，CLR會拋出異常，提示無法在非UI線程中更新界面上的控制項（Cross-thread operation not valid）。一般情況下有兩種解決辦法。第一種就是設置Control的靜態屬性為False，如下：publicForm1(){
InitializeComponent();
Control.=false;}privatevoidbutton1_Click(objectsender, EventArgs e){
Thread thread=newThread(()={for(inti=0; i<100000; i++){
label1.Text=
i.ToString();
label1.Refresh();}});
thread.Start();}
另一種辦法，就是使用委託，根據控制項的InvokeRequired屬性判斷當前控制項的更新操作是否是在另一個線程中。如果是，
則使用委託進行方法調用並更新控制項。但是這種方法有個缺點，就是需要針對每個控制項的屬性設置方式創建一些單獨的委託和方法，這些委託和方法僅僅是在解決跨線程操作的時候使用。比如，你在另一個線程中需要修改某個label的text時，你就需要創建一個SetLabelText方法，假設你還需要更新TextBox的text，那麼你還需要另外創建一個SetTextBoxText方法。
通過下面的委託和方法的定義，我們實現了一次定義，多次使用。請看：(paramsobject[] args);(Component c,
ParameterizedControlUpdate callback,paramsobject[] args);(Component c,
ParameterizedControlUpdate callback,paramsobject[] args){
Control target=(cisControl)?(casControl) :this;if(target.InvokeRequired){
ControlUpdateDelegate d=DelegatedControlUpdate;
target.Invoke(d,
newobject[] { c, callback, args });}else{
callback(args);}}
於是，上面的例子可以改為：privatevoidbutton1_Click(objectsender, EventArgs e){
Thread thread=newThread(()={for(inti=0; i<100000; i++){
DelegatedControlUpdate(label1, args={
label1.Text=(string)args[0];
label1.Refresh();
⑥ vc多線程參數傳遞問題
可以這樣做:
為線程參數定義一個結構體
struct threadParam
{
HANDLE* self;
HANDLE* other;
//還可以定義一些其他你認為需要的參數
};
//假設有2個線程A、B
HANDLE *HA = new HANDLE;
HANDLE *HB = new HANDLE;
threadParam *pA = new threadParam;
PA->self = HA;
PA->other = HB;
*HA = createthread(NULL,funcA,PA,....);
將PA做為參數傳遞給線程A。這樣就可以在線程函數里通過指針使用a,b的線程句柄了。
同樣創建b線程的時候這樣做一遍就ok。
不知道這樣說明白否？
⑦ C#中如何從指定文件中一秒鍾讀取一行數據，要用線程
public void ReadTest(string filename)
{
Thread readthread = new Thread(new ParameterizedThreadStart(Read));
readthread.Start("c:\\1.txt");
}
public void Read(object file)
{
string fileurl = file as string;
StreamReader sr = new StreamReader(fileurl);
string result;
while (true)
{
result = sr.ReadLine();
if (result == null)
break;
textbox1.append(result);
Thread.Sleep(1000);
}
sr.Close();
}
以上代碼你在調試下會出現 無法跨線程 調用控制項的異常。你可以不用管它，你直接運行Debug下的exe，是可以運行的。原因是顯示控制項和處理消息隊列是系統調用了GUI線程，你在調試的情況下調試環境是不允許你跨線程調用GUI線程（Main方法的主線程除外），所以運行程序的時候要直接運行Debug下的exe。
當然，你也可以利用Control. = false; 加入這句代碼在Thread readthread = new Thread(new ParameterizedThreadStart(Read));
之前
調試時也不會提示出錯，可以正常執行上面的程序。
⑧ 線程、進程在跨線程（進程）訪問內存，許可權有什麼不同
說法一：進程是具有一定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位.
線程是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源.
一個線程可以創建和撤銷另一個線程;同一個進程中的多個線程之間可以並發執行
說法二：進程和線程都是由操作系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的並發性。進程和線程的區別在於：
簡而言之,一個程序至少有一個進程,一個進程至少有一個線程.
線程的劃分尺度小於進程，使得多線程程序的並發性高。
另外，進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，從而極大地提高了程序的運行效率。
線程在執行過程中與進程還是有區別的。每個獨立的線程有一個程序運行的入口、順序執行序列和程序的出口。但是線程不能夠獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。
從邏輯角度來看，多線程的意義在於一個應用程序中，有多個執行部分可以同時執行。但操作系統並沒有將多個線程看做多個獨立的應用，來實現進程的調度和管理以及資源分配。這就是進程和線程的重要區別。
說法三：多線程共存於應用程序中是現代操作系統中的基本特徵和重要標志。用過UNIX操作系統的讀者知道進程，在UNIX操作系統中，每個應用程序的執行都在操作系統內核中登記一個進程標志，操作系統根據分配的標志對應用程序的執行進行調度和系統資源分配，但進程和線程有什麼區別呢？
進程和線程都是由操作系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的並發性。進程和線程的區別在於：
線程的劃分尺度小於進程，使得多線程程序的並發性搞。
另外，進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，從而極大地提高了程序的運行效率。
線程在執行過程中與進程還是有區別的。每個獨立的線程有一個程序運行的入口、順序執行序列和程序的出口。但是線程不能夠獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。
從邏輯角度來看，多線程的意義在於一個應用程序中，有多個執行部分可以同時執行。但操作系統並沒有將多個線程看做多個獨立的應用，來實現進程的調度和管理以及資源分配。這就是進程和線程的重要區別。
進程（Process）是最初定義在Unix等多用戶、多任務操作系統環境下用於表示應用程序在內存環境中基本執行單元的概念。以Unix操作系統為例，進程是Unix操作系統環境中的基本成分、是系統資源分配的基本單位。Unix操作系統中完成的幾乎所有用戶管理和資源分配等工作都是通過操作系統對應用程序進程的控制來實現的。
C、C++、Java等語言編寫的源程序經相應的編譯器編譯成可執行文件後，提交給計算機處理器運行。這時，處在可執行狀態中的應用程序稱為進程。從用戶角度來看，進程是應用程序的一個執行過程。從操作系統核心角度來看，進程代表的是操作系統分配的內存、CPU時間片等資源的基本單位，是為正在運行的程序提供的運行環境。進程與應用程序的區別在於應用程序作為一個靜態文件存儲在計算機系統的硬碟等存儲空間中，而進程則是處於動態條件下由操作系統維護的系統資源管理實體。多任務環境下應用程序進程的主要特點包括：
●進程在執行過程中有內存單元的初始入口點，並且進程存活過程中始終擁有獨立的內存地址空間；
●進程的生存期狀態包括創建、就緒、運行、阻塞和死亡等類型；
●從應用程序進程在執行過程中向CPU發出的運行指令形式不同，可以將進程的狀態分為用戶態和核心態。處於用戶態下的進程執行的是應用程序指令、處於核心態下的應用程序進程執行的是操作系統指令。
在Unix操作系統啟動過程中，系統自動創建swapper、init等系統進程，用於管理內存資源以及對用戶進程進行調度等。在Unix環境下無論是由操作系統創建的進程還要由應用程序執行創建的進程，均擁有唯一的進程標識（PID）。
說法四：應用程序在執行過程中存在一個內存空間的初始入口點地址、一個程序執行過程中的代碼執行序列以及用於標識進程結束的內存出口點地址，在進程執行過程中的每一時間點均有唯一的處理器指令與內存單元地址相對應。
Java語言中定義的線程（Thread）同樣包括一個內存入口點地址、一個出口點地址以及能夠順序執行的代碼序列。但是進程與線程的重要區別在於線程不能夠單獨執行，它必須運行在處於活動狀態的應用程序進程中，因此可以定義線程是程序內部的具有並發性的順序代碼流。
Unix操作系統和Microsoft Windows操作系統支持多用戶、多進程的並發執行，而Java語言支持應用程序進程內部的多個執行線程的並發執行。多線程的意義在於一個應用程序的多個邏輯單元可以並發地執行。但是多線程並不意味著多個用戶進程在執行，操作系統也不把每個線程作為獨立的進程來分配獨立的系統資源。進程可以創建其子進程，子進程與父進程擁有不同的可執行代碼和數據內存空間。而在用於代表應用程序的進程中多個線程共享數據內存空間，但保持每個線程擁有獨立的執行堆棧和程序執行上下文（Context）。
基於上述區別，線程也可以稱為輕型進程 (Light Weight Process，LWP)。不同線程間允許任務協作和數據交換，使得在計算機系統資源消耗等方面非常廉價。
線程需要操作系統的支持，不是所有類型的計算機都支持多線程應用程序。Java程序設計語言將線程支持與語言運行環境結合在一起，提供了多任務並發執行的能力。這就好比一個人在處理家務的過程中，將衣服放到洗衣機中自動洗滌後將大米放在電飯鍋里，然後開始做菜。等菜做好了，飯熟了同時衣服也洗好了。
需要注意的是：在應用程序中使用多線程不會增加 CPU 的數據處理能力。只有在多CPU 的計算機或者在網路計算體系結構下，將Java程序劃分為多個並發執行線程後，同時啟動多個線程運行，使不同的線程運行在基於不同處理器的Java虛擬機中，才能提高應用程序的執行效率。
⑨ unity c#跨線程調用怎麼實現
在unity里邊使用多線程做一些事情是非常好的，比如解壓資源 更新資源等。因為單開線程的話 不會影響主線程卡頓，這樣UI就不會卡了。但是開的線程里邊不能執行unity主線程的mono代碼。線程啟動後，執行完畢自動結束該線程、可以同時啟動多個線程做事。
代碼如下： using System.Threading;
void StartThread()
{
Thread athread = new Thread(new ThreadStart(goThread));
athread.IsBackground = true;//防止後台現成。相反需要後台線程就設為false
athread.Start();
}
void Awake()
{
StartThread();
}
object lockd = new object();
void goThread()
{
int index = 0;
while (true)
{
lock (lockd)//防止其他線程訪問當前線程使用的數據
{
Debug.Log("in thread" + index);
index++;
if (index == 100)
{
Thread.Sleep(10000);// 將當前線程掛起指定的時間 毫秒 時間結束後 繼續執行下一步 和yield類似
}
else if (index == 200)
{
break;//該函數執行完自動結束該線程
}
}
}
}
所以其實多線程和協程原理差別很大的，只是功能有點類似。
1、當在主線程中創建了一個線程，那麼該線程的IsBackground默認是設置為FALSE的。
2、當主線程退出的時候，IsBackground=FALSE的線程還會繼續執行下去，直到線程執行結束。
3、只有IsBackground=TRUE的線程才會隨著主線程的退出而退出
---------------------------------------------------------------------------------------------
ThreadStart：
Thread athread = new Thread(new ThreadStart(goThread));
athread.Start();//該方法啟動的多線程 不能帶有參數。
ParameterThreadStart：
ParameterThreadStart的定義為void ParameterizedThreadStart(object state)，使用這個這個委託定義的線程的啟動函數可以接受一個輸入參數,具體例子如下 ：
[csharp] view plain
ParameterizedThreadStart threadStart=new ParameterizedThreadStart(Calculate)
Thread thread=new Thread() ;
thread.Start(0.9);//參數是0.9
public void Calculate(object arg)//arg參數是0.9
{
double Diameter=double(arg);
Console.Write("The Area Of Circle with a Diameter of {0} is {1}"Diameter,Diameter*Math.PI);
}
Calculate方法只有一個為object類型的參數。需要傳多個參數的時候 需要把參數都塞進object 然後進行轉換。比如：
一個參數 void BuildA(object para){ List<int> list=para as List<int>;...}
BuildA(list);
多個參數 void BuildB(object para){ object[] ps= para as object[];List<int> list=ps[0] as as List<int>;GameObject b=ps[1] as GameObject;...}
BuildB(new object[]{list,obj});//把多個參數塞到object數組里邊 傳過去，相當於只傳一個參數。
至於是開一個線程還是多個線程 根據需求和內核數SystemInfo.processorCount來確定。最好一個核開一個線程 會快點。
詳見bundleglobal.cs和sdFileSystem.cs/sdMultiThread.cs
⑩ 請教c#多線程操作更新控制項的簡便方法
char*c[]={"ENTER","NEW","POIT","FIRST"};//指針數組，數組的每個元素是指針，這里存常量字元串的首地址。char**cp[]={c+3,c+2,c+1,c};//二級指針數組，數組每個元素是二級指針，這里存了c[3].c[2],c[1],c[0]的地址,也就是上面字元串順序逆序char***cpp=cp;三級指針指向cp數組首地址。ps，一般三級指針在正常的程序里不會出現，容易形成非常混亂的局面。printf("%s\n",**++cpp);POIT//優先順序相同，臨近原則++cpp--->c+2的地址,兩次間址是POITprintf("%s\n,",*--*++cpp);ENTER//++cpp--->cp+1（上面自增過了），間址一次變成cp[1]，--c+1再間地址，就是c第一個元素。ENTER。printf("%s\n",*cpp[-2]+3);ST//cpp指向c+1的位置。cpp[-2]就是*(cpp-2)指向cp+0,就是c+3*(c+3)+3不就是FIRST數第四個字母么，後面輸出ST。printf("%s\n",cpp[-1][-1]+1);上面cpp還是指向在c+1,*(cpp-1)是c+2,*(*c+2-1)--->c+1,NEW這個單詞地址，*((*(c+1))+1)數到E往後輸出}