Multithreaded Application Tutorial/pl: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1		-	~~<div style="font-size:1.88em;margin:0.75em 0;">~~
2		-
3	1		Kurs tworzenia aplikacji wielowątkowych
4		-
5		-	~~</div>~~
6	2
7	3		## Wprowadzenie
8	4
9	5		Na tej stronie spróbujemy wyjaśnić, w jaki sposób napisać i debugować aplikacje wielowątkowe przy pomocy Free Pascala i Lazarusa. Aplikacja wielowątkowa to program, który tworzy dwa lub więcej wątków wykonawczych działających w tym samym czasie. Jeśli nie miałeś dotąd do czynienia z wielowątkowością, przeczytaj akapit „Czy potrzebujesz wielowątkowości?” aby ustalić, czy jest ci to naprawdę potrzebne, bo być może zaoszczędzisz sobie bólu głowy.
10	6
11	7		Pierwszy wątek nazywany jest głównym wątkiem. Główny wątek to ten, który jest tworzony przez System Operacyjny, to ten sam, w którym nasza aplikacja rozpoczyna działanie. Główny wątek musi być jedynym wątkiem, który aktualizuje komponenty do komunikacji z użytkownikiem: w przeciwnym wypadku, aplikacja może się zawiesić.
12	8
13	9		Podstawowym założeniem jest to, aby aplikacja mogła przetwarzać pewne dane w tle, tj. w drugim wątku, podczas gdy użytkownik może kontynuować pracę przy użyciu głównego wątku.
14	10
15	11		Innym zastosowaniem wątków jest po prostu możliwość lepszej reakcji programu. Jeśli tworzysz dużą aplikację lub gdy użytkownik naciśnie przycisk aplikacji rozpoczynając jakiś duży proces ... dopóki trwa przetwarzanie, ekran przestaje odpowiadać, co powoduje błędne lub mylące wrażenie, że aplikacja jest zawieszona. Jeśli duży proces przebiega w drugim wątku, aplikacja zachowuje się (prawie) tak, jakby była w stanie bezczynności. W tym przypadku dobrym pomysłem jest aby, przed rozpoczęciem wątku, wyłączyć odpowiednie przyciski na formularzu, w celu uniknięcia ponownego uruchomienia drugiego wątku przez użytkownika.
16	12
17	13		Jeszcze innym zastosowaniem wielowątkowości może być serwer, który jest w stanie dać odpowiedź wielu klientom, w tym samym czasie.
18	14
19	15		## Czy potrzebujesz wielowątkowości?
20	16
21	17		Jeśli dopiero poznajesz wielowątkowość i chciałbyś tylko stworzyć aplikację z szybszym czasem reakcji w chwili gdy wykonuje ona umiarkowanie długotrwałe zadanie, wówczas wielowątkowość może być nadmiarowa w stosunku do wymagań. Aplikacje wielowątkowe są zawsze trudniejsze do debugowania i często są znacznie bardziej skomplikowane, jednak w wielu przypadkach wcale nie potrzebujesz używać wielowątkowości. Jeden wątek jest wystarczający. Możesz podzielić czasochłonne zadanie na kilka mniejszych części, oraz użyć procedurę Application.ProcessMessages. Procedura ta pozwala bibliotece LCL obsłużyć wszystkie oczekujące komunikaty i powrócić do miejsca jej wywołania. Główną ideą jest to, aby wywoływać Application.ProcessMessages w regularnych odstępach czasu w trakcie wykonywania długotrwałego zadania, np. po to aby sprawdzić, czy użytkownik kliknął na jakąś kontrolkę lub czy wskaźnik postępu musi zostać przemalowany albo zdarzyło się jeszcze coś innego.
22	18
23	19		Przykład: Czytanie dużego pliku i jego przetwarzanie. Zobacz: examples/multithreading/singlethreadingexample1.lpi.
24	20
25	21		Wielowątkowość jest potrzebna tylko w przypadku
26	22
27	23		- używania uchwytów blokujących, takich jak w komunikacji sieci
28	24		- korzystania z wielu procesorów jednocześnie (SMP)
29	25		- algorytmów i bibliotek, które muszą być wywoływane przez API i jako takie nie mogą być podzielone na mniejsze części.
30	26
31	27		Jeśli chcesz użyć wielowątkowości, aby zwiększyć prędkość przy użyciu wielu procesorów jednocześnie, sprawdź, czy twój obecny program w tej chwili wykorzystuje 100% zasobów 1 rdzenia CPU (na przykład, program może aktywnie korzystać z operacji wejścia-wyjścia, jak zapis do pliku i to zajmuje dużo czasu, ale nie obciąża procesora, i w tym przypadku program nie będzie działał szybciej z wieloma wątkami). Należy również sprawdzić, czy poziom optymalizacji jest ustawiony na maksymalny (3). Przełączając poziom optymalizacji z 1 na 3, program może stać się około 5 razy szybszy.
32	28
33	29		## Moduły potrzebne do tworzenia aplikacji wielowątkowej
34	30
35	31		Nie potrzebujesz żadnych specjalnych modułów do tego, aby pracować z systemem Windows. Jednak w przypadku Linuksa, Mac OS X i FreeBSD, należy użyć modułu cthreads i musi być on użyty jako pierwszy moduł projektu (program źródłowy, zwykle znajdujący się w pliku .lpr)!
36	32
37	33		Dlatego twój kod aplikacji Lazarusa powinien wyglądać tak:
38	34
39	35		``` pascal
40	36		program MyMultiThreadedProgram;
41	37		{$mode objfpc}{$H+}
42	38		uses
43	39		{$ifdef unix}
44	40		cthreads,
45	41		cmem, // menedżer pamięci c jest w niektórych systemach znacznie szybszy dla aplikacji wielowątkowych
46	42		{$endif}
47	43		Interfaces, // to zawiera widżety LCL
48	44		Forms
49	45		{ tu możesz dodać następne moduły },
50	46		```
51	47
52	48		Jeśli o tym zapomnisz i użyjesz TThread, otrzymasz następujący błąd podczas uruchamiania:
53	49
54	50		` This binary has no thread support compiled in.`\
55	51		` Recompile the application with a thread-driver in the program uses clause before other units using thread.`
56	52
57	53		> Note: Jeśli pojawi się błąd linkera o tym, że nie znaleziono „mcount” to znaczy, że używasz jakiegoś modułu, który zawiera kod wielowątkowy i musisz dodać moduł cthreads lub użyć [[smart linking\|sprytnego łączenia]].
58	54
59	55		> Note: Jeśli w procedurze SYSTEM_NOTHREADERROR otrzymasz błąd: „Project raised exception class 'RunError(232)'” to znaczy, że twój kod potrzebuje wątków i musisz dodać moduł cthreads.
60	56
61	57		## Przykład w czystym FPC
62	58
63	59		Poniższy kod przedstawia bardzo prosty przykład. Testowany z FPC 3.0.4 na Win7.
64	60
65	61		``` pascal
66	62		Program ThreadTest;
67	63		{ przetestuj możliwość aplikacji wielowątkowej }
68	64		{
69	65		OUTPUT
70	66		wątek 1 uruchomiony
71	67		wątek 1 zmienna thri 0 Długość(s)= 1
72	68		wątek 1 zmienna thri 1 Długość(s)= 2
73	69		wątek 1 zmienna thri 2 Długość(s)= 3
74	70		wątek 1 zmienna thri 3 Długość(s)= 4
75	71		wątek 1 zmienna thri 4 Długość(s)= 5
76	72		wątek 1 zmienna thri 5 Długość(s)= 6
77	73		wątek 1 zmienna thri 6 Długość(s)= 7
78	74		wątek 1 zmienna thri 7 Długość(s)= 8
79	75		wątek 1 zmienna thri 8 Długość(s)= 9
80	76		wątek 1 zmienna thri 9 Długość(s)= 10
81	77		wątek 1 zmienna thri 10 Długość(s)= 11
82	78		wątek 1 zmienna thri 11 Długość(s)= 12
83	79		wątek 1 zmienna thri 12 Długość(s)= 13
84	80		wątek 1 zmienna thri 13 Długość(s)= 14
85	81		wątek 1 zmienna thri 14 Długość(s)= 15
86	82		wątek 2 uruchomiony
87	83		wątek 3 uruchomiony
88	84		wątek 1 zmienna thri 15 Długość(s)= 16
89	85		wątek 2 zmienna thri 0 Długość(s)= 1
90	86		wątek 3 zmienna thri 0 Długość(s)= 1
91	87		wątek 1 zmienna thri 16 Długość(s)= 17
92	88		...
93	89		...
94	90		wątek 5 zmienna thri 997 Długość(s)= 998
95	91		wątek 5 zmienna thri 998 Długość(s)= 999
96	92		wątek 5 zmienna thri 999 Długość(s)= 1000
97	93		wątek 5 zakończony
98	94		wątek 10 zmienna thri 828 Długość(s)= 829
99	95		wątek 9 zmienna thri 675 Długość(s)= 676
100	96		wątek 4 zmienna thri 656 Długość(s)= 657
101	97		wątek 10 zmienna thri 829 Długość(s)= 830
102	98		wątek 9 zmienna thri 676 Długość(s)= 677
103	99		wątek 9 zmienna thri 677 Długość(s)= 678
104	100		wątek 10 zmienna thri 830 Długość(s)= 831
105	101		wątek 10 zmienna thri 831 Długość(s)= 832
106	102		wątek 10 zmienna thri 832 Długość(s)= 833
107	103		wątek 10 zmienna thri 833 Długość(s)= 834
108	104		wątek 10 zmienna thri 834 Długość(s)= 835
109	105		wątek 10 zmienna thri 835 Długość(s)= 836
110	106		wątek 10 zmienna thri 836 Długość(s)= 837
111	107		wątek 10 zmienna thri 837 Długość(s)= 838
112	108		wątek 10 zmienna thri 838 Długość(s)= 839
113	109		wątek 10 zmienna thri 839 Długość(s)= 840
114	110		wątek 9 zmienna thri 678 Długość(s)= 679
115	111		...
116	112		...
117	113		wątek 4 zmienna thri 994 Długość(s)= 995
118	114		wątek 4 zmienna thri 995 Długość(s)= 996
119	115		wątek 4 zmienna thri 996 Długość(s)= 997
120	116		wątek 4 zmienna thri 997 Długość(s)= 998
121	117		wątek 4 zmienna thri 998 Długość(s)= 999
122	118		wątek 4 zmienna thri 999 Długość(s)= 1000
123	119		wątek 4 zakończony
124	120		10
125	121
126	122		}
127	123
128	124		uses
129	125		{$ifdef unix}cthreads, {$endif} sysutils;
130	126
131	127		const
132	128		threadcount = 10;
133	129		stringlen = 1000;
134	130
135	131		var
136	132		finished : longint;
137	133
138	134		threadvar
139	135		thri : ptrint;
140	136
141	137		function f(p : pointer) : ptrint;
142	138		var
143	139		s : ansistring;
144	140		begin
145	141		Writeln('wątek ',longint(p),' uruchomiony');
146	142		thri:=0;
147	143		while (thri<stringlen) do begin
148	144		s:=s+'1'; { stwórz opóźnienie }
149	145		writeln('wątek ',longint(p),' zmienna thri ',thri,' Długość(s)= ',length(s));
150	146		inc(thri);
151	147		end;
152	148		Writeln('wątek ',longint(p),' zakończony');
153	149		InterLockedIncrement(finished);
154	150		f:=0;
155	151		end;
156	152
157	153		var
158	154		i : longint;
159	155
160	156		Begin
161	157		finished:=0;
162	158		for i:=1 to threadcount do
163	159		BeginThread(@f,pointer(i));
164	160		while finished<threadcount do ;
165	161		Writeln(finished);
166	162		End.
167	163		```
168	164
169	165		## Klasa TThread
170	166
171	167		Poniższy przykład można znaleźć w katalogu examples/multithreading/.
172	168
173	169		Aby utworzyć aplikację wielowątkową, najłatwiej jest użyć klasy TThread. Ta klasa pozwala w prosty sposób stworzyć dodatkowy wątek (obok głównego wątku). Zwykle wymagane jest przesłonięcie tylko dwóch metod: konstruktora Create i metody Execute.
174	170
175	171		W konstruktorze przygotujesz wątek do uruchomienia. Ustawisz początkowe wartości dla zmiennych lub właściwości, których potrzebujesz. Oryginalny konstruktor TThread wymaga parametru o nazwie Suspended. Jak można się spodziewać, ustawienie Suspended = True zapobiegnie automatycznemu uruchomieniu wątku po utworzeniu. Jeśli Suspended = False, wątek zacznie działać zaraz po utworzeniu. Jeśli wątek zostanie utworzony jako zawieszony, zostanie uruchomiony dopiero po wywołaniu metody Start.
176	172
177	173		> Note: Metoda Resume jest [przestarzała od FPC 2.4.4](http://wiki.freepascal.org/User_Changes_2.4.4#TThread.Suspend_and_TThread.Resume_have_been_deprecated). Została zastąpiona przez metodę Start.
178	174
179	175		Począwszy od wersji FPC 2.0.1 i nowszych, TThread.Create ma również niejawny parametr dla rozmiaru stosu. W razie potrzeby możesz teraz zmienić domyślny rozmiar stosu każdego utworzonego wątku. Dobrym przykładem są głębokie rekurencje wywołań procedur w wątku. Jeśli nie określisz parametru rozmiaru stosu, zostanie użyty domyślny rozmiar stosu systemu operacyjnego.
180	176
181	177		W zastąpionej metodzie Execute napisz kod, który będzie uruchamiany w wątku.
182	178
183	179		Klasa TThread ma jedną ważną właściwość: Terminated : boolean;
184	180
185	181		Jeśli wątek ma pętlę (i jest to typowe), pętla powinna zostać zakończona, gdy Terminated ma wartość true (domyślnie jest to false). W każdym przebiegu należy sprawdzić wartość Terminated, a jeśli jest prawdziwa, pętla powinna zostać zakończona tak szybko, jak to konieczne, po każdym koniecznym czyszczeniu. ~~Należy pamiętać, że metoda Terminate domyślnie nic nie robi: metoda .Execute musi jawnie zaimplementować obsługę, aby zakończyć swoje zadanie.~~ Metoda Terminate domyślnie ustawia jedynie właściwość Terminated na wartość True.
186	182
187	183		Jak wyjaśniliśmy wcześniej, wątek nie powinien wchodzić w interakcje z widocznymi komponentami. Aktualizacje widocznych komponentów muszą być dokonywane w kontekście głównego wątku.
188	184
189	185		Aby to zrobić, istnieje metoda TThread o nazwie Synchronize. Synchronize wymaga metody w wątku (która nie przyjmuje parametrów) jako argumentu. Po wywołaniu tej metody za pomocą Synchronize(@MyMethod) wykonanie wątku zostanie wstrzymane, kod MyMethod zostanie wywołany z głównego wątku, a następnie zostanie wznowione wykonywanie wątku.
190	186
191	187		Dokładne działanie metody Synchronize zależy od platformy, ale zasadniczo wykonuje ona:
192	188
193	189		- wysyła wiadomość do głównej kolejki wiadomości i zasypia
194	190		- ostatecznie główny wątek przetwarza wiadomość i wywołuje MyMethod. W ten sposób MyMethod jest wywoływana bez kontekstu, co oznacza, że nie wykonuje się podczas zdarzenia wciśnięcia myszy lub podczas malowania, ale po.
195	191		- po wykonaniu przez główny wątek MyMethod, budzi ona uśpiony wątek i przetwarza następną wiadomość
196	192		- następnie wątek jest kontynuowany.
197	193
198	194		Jest jeszcze jedna ważna właściwość TThread: FreeOnTerminate. Jeśli ta właściwość ma wartość true, obiekt wątku jest automatycznie zwalniany po zatrzymaniu wykonywania wątku (metoda .Execute). W przeciwnym razie aplikacja będzie musiała zwolnić ją ręcznie.
199	195
200	196		Przykład:
201	197
202	198		``` pascal
203	199		Type
204	200		TMyThread = class(TThread)
205	201		private
206	202		fStatusText : string;
207	203		procedure ShowStatus;
208	204		protected
209	205		procedure Execute; override;
210	206		public
211	207		Constructor Create(CreateSuspended : boolean);
212	208		end;
213	209		constructor TMyThread.Create(CreateSuspended : boolean);
214	210		begin
215	211		inherited Create(CreateSuspended);
216	212		FreeOnTerminate := True;
217	213		end;
218	214
219	215		procedure TMyThread.ShowStatus;
220	216		// ta metoda jest wykonywana przez główny wątek i dlatego może uzyskać dostęp do wszystkich elementów GUI.
221	217		begin
222	218		Form1.Caption := fStatusText;
223	219		end;
224	220
225	221		procedure TMyThread.Execute;
226	222		var
227	223		newStatus : string;
228	224		begin
229	225		fStatusText := 'TMyThread Starting...';
230	226		Synchronize(@Showstatus);
231	227		fStatusText := 'TMyThread Running...';
232	228		while (not Terminated) and ([inne wymagane warunki]) do
233	229		begin
234	230		...
235	231		[tutaj jest kod głównej pętli wątku]
236	232		...
237	233		if NewStatus <> fStatusText then
238	234		begin
239	235		fStatusText := newStatus;
240	236		Synchronize(@Showstatus);
241	237		end;
242	238		end;
243	239		end;
244	240		```
245	241
246	242		W aplikacji:
247	243
248	244		``` pascal
249	245		var
250	246		MyThread : TMyThread;
251	247		begin
252	248		MyThread := TMyThread.Create(True); // W ten sposób nie uruchamia się automatycznie
253	249		...
254	250		[Tutaj kod inicjuje wszystko, co jest wymagane, zanim wątki zaczną się wykonywać]
255	251		...
256	252		MyThread.Start;
257	253		end;
258	254		```
259	255
260	256		Jeśli chcesz, aby Twoja aplikacja była bardziej elastyczna, możesz utworzyć zdarzenie dla wątku; w ten sposób Twoja zsynchronizowana metoda nie będzie ściśle powiązana z określoną formą lub klasą: możesz dołączyć detektory do zdarzenia wątku. Oto przykład:
261	257
262	258		``` pascal
263	259		Type
264	260		TShowStatusEvent = procedure(Status: String) of Object;
265	261
266	262		TMyThread = class(TThread)
267	263		private
268	264		fStatusText : string;
269	265		FOnShowStatus: TShowStatusEvent;
270	266		procedure ShowStatus;
271	267		protected
272	268		procedure Execute; override;
273	269		public
274	270		Constructor Create(CreateSuspended : boolean);
275	271		property OnShowStatus: TShowStatusEvent read FOnShowStatus write FOnShowStatus;
276	272		end;
277	273
278	274		constructor TMyThread.Create(CreateSuspended : boolean);
279	275		begin
280	276		inherited Create(CreateSuspended);
281	277		FreeOnTerminate := True;
282	278		end;
283	279
284	280		procedure TMyThread.ShowStatus;
285	281		// ta metoda jest wykonywana przez główny wątek i dlatego może uzyskać dostęp do wszystkich elementów GUI.
286	282		begin
287	283		if Assigned(FOnShowStatus) then
288	284		begin
289	285		FOnShowStatus(fStatusText);
290	286		end;
291	287		end;
292	288
293	289		procedure TMyThread.Execute;
294	290		var
295	291		newStatus : string;
296	292		begin
297	293		fStatusText := 'TMyThread Starting...';
298	294		Synchronize(@Showstatus);
299	295		fStatusText := 'TMyThread Running...';
300	296		while (not Terminated) and ([inne wymagane warunki]) do
301	297		begin
302	298		...
303	299		[tutaj jest kod głównej pętli wątku]
304	300		...
305	301		if NewStatus <> fStatusText then
306	302		begin
307	303		fStatusText := newStatus;
308	304		Synchronize(@Showstatus);
309	305		end;
310	306		end;
311	307		end;
312	308		```
313	309
314	310		W aplikacji:
315	311
316	312		``` pascal
317	313		Type
318	314		TForm1 = class(TForm)
319	315		Button1: TButton;
320	316		Label1: TLabel;
321	317		procedure Button1Click(Sender: TObject);
322	318		procedure FormCreate(Sender: TObject);
323	319		procedure FormDestroy(Sender: TObject);
324	320		private
325	321		{ private declarations }
326	322		MyThread: TMyThread;
327	323		procedure ShowStatus(Status: string);
328	324		public
329	325		{ public declarations }
330	326		end;
331	327
332	328		procedure TForm1.FormCreate(Sender: TObject);
333	329		begin
334	330		inherited;
335	331		MyThread := TMyThread.Create(true);
336	332		MyThread.OnShowStatus := @ShowStatus;
337	333		end;
338	334
339	335		procedure TForm1.FormDestroy(Sender: TObject);
340	336		begin
341	337		MyThread.Terminate;
342	338
343	339		// FreeOnTerminate ma wartość true więc nie powinniśmy pisać:
344	340		// MyThread.Free;
345	341		inherited;
346	342		end;
347	343
348	344		procedure TForm1.Button1Click(Sender: TObject);
349	345		begin
350	346		MyThread.Start;
351	347		end;
352	348
353	349		procedure TForm1.ShowStatus(Status: string);
354	350		begin
355	351		Label1.Caption := Status;
356	352		end;
357	353		```
358	354
359	355		## Ważne rzeczy, na które trzeba zwrócić uwagę
360	356
361	357		### Kontrola stosu w systemie Windows
362	358
363	359		Może wystąpić potencjalny problem w systemie Windows, jeśli używasz przełącznika -Ct (sprawdzanie stosu). Z powodów, które nie są do końca jasne, sprawdzanie stosu będzie „wyzwalane” z każdym wywołaniem TThread.Create, jeśli używasz domyślnego rozmiaru stosu. W tej chwili jedynym rozwiązaniem jest po prostu nieużywanie przełącznika -Ct. Zauważ, że NIE powoduje to wyjątku w głównym wątku, ale w nowo utworzonym. To „wygląda” tak, jakby wątek nigdy nie został uruchomiony.
364	360
365	361		Poprawny kod do sprawdzenia tego i innych wyjątków, które mogą wystąpić podczas tworzenia wątków, to:
366	362
367	363		``` pascal
368	364		MyThread := TThread.Create(False);
369	365
370	366		if Assigned(MyThread.FatalException) then
371	367		raise MyThread.FatalException;
372	368		```
373	369
374	370		Ten kod zapewni, że każdy wyjątek, który wystąpił podczas tworzenia wątku, zostanie zgłoszony w głównym wątku.
375	371
376	372		### Wielowątkowość w pakietach
377	373
378	374		Pakiety korzystające z wielowątkowości powinny dodawać flagę -dUseCThreads do dodatkowo używanych opcji. Otwórz edytor pakietów, a następnie Opcje \> Użycie \> Dodatkowe i dodaj -dUseCThreads. Spowoduje to zdefiniowanie tej flagi dla wszystkich projektów i pakietów korzystających z tego pakietu, w tym IDE. IDE i wszystkie nowe aplikacje utworzone przez IDE mają już następujący kod w swoim pliku .lpr:
379	375
380	376		``` pascal
381	377		uses
382	378		{$IFDEF UNIX}{$IFDEF UseCThreads}
383	379		cthreads,
384	380		cmem, // Menedżer pamięci c jest w niektórych systemach znacznie szybszy w przypadku wielowątkowości
385	381		{$ENDIF}{$ENDIF}
386	382		```
387	383
388	384		### Moduł Heaptrc
389	385
390	386		Nie można używać przełącznika -gh z modułem cmem. Przełącznik -gh używa modułu heaptrc, który rozszerza menedżer stosu. Dlatego moduł heaptrc musi być używany po module cmem.
391	387
392	388		``` pascal
393	389		uses
394	390		{$IFDEF UNIX}{$IFDEF UseCThreads}
395	391		cthreads,
396	392		cmem, // Menedżer pamięci c jest w niektórych systemach znacznie szybszy w przypadku wielowątkowości
397	393		{$ENDIF}{$ENDIF}
398	394		heaptrc,
399	395		```
400	396
401	397		### Initialization and Finalization
402	398
403	399		Aby zainicjować sam obiekt wątku, możesz uruchomić go w trybie zawieszenia i ustawić jego właściwości i/lub utworzyć nowy konstruktor i wywołać odziedziczony konstruktor.
404	400
405	401		Uwaga: Używanie AfterConstruction, gdy CreateSuspended=false jest niebezpieczne, ponieważ wątek już zaczął działać.
406	402
407	403		Z drugiej strony, destruktor może służyć do finalizowania zasobów obiektu.
408	404
409	405		``` pascal
410	406		type
411	407		TMyThread = class(TThread)
412	408		private
413	409		fRTLEvent: PRTLEvent;
414	410		public
415	411		procedure Create(SomeData: TSomeObject); override;
416	412		destructor Destroy; override;
417	413		end;
418	414
419	415		procedure TMyThread.Create(SomeData: TSomeObject; CreateSuspended: boolean);
420	416		begin
421	417		// przykład: skonfiguruj zdarzenia, sekcje krytyczne i inne zasoby, takie jak pliki lub połączenia z bazami danych
422	418		RTLEventCreate(fRTLEvent);
423	419		inherited Create(CreateSuspended);
424	420		end;
425	421
426	422		destructor TMyThread.Destroy;
427	423		begin
428	424		RTLeventDestroy(fRTLEvent);
429	425		inherited Destroy;
430	426		end;
431	427		```
432	428
433	429		### Program bez LCL
434	430
435	431		TThread.Synchronize wymaga, aby główny wątek regularnie wywoływał CheckSynchronize. LCL robi to w swojej pętli. Jeśli nie używasz pętli zdarzeń LCL, musisz ją wywołać samodzielnie.
436	432
437	433		## Wsparcie dla SMP
438	434
439	435		Dobrą wiadomością jest to, że jeśli Twoja aplikacja działa poprawnie wielowątkowo, to w ten sposób, jest już włączona obsługa SMP, czyli przetwarzanie wątków przez wiele procesorów!
440	436
441	437		## Debugowanie aplikacji wielowątkowych w Lazarusie
442	438
443	439		Debugowanie na Lazarusie wymaga [[GDB/pl\|GDB]] i szybko staje się coraz bardziej funkcjonalne i stabilne. Jednak nadal istnieje kilka dystrybucji Linuksa z pewnymi problemami.
444	440
445	441		### Wyjście debuggera
446	442
447	443		W jednowątkowej aplikacji możesz po prostu pisać do konsoli/terminala/gdziekolwiek, a kolejność wierszy jest taka sama, jak zostały one napisane. W aplikacjach wielowątkowych sprawy są bardziej skomplikowane. Jeśli dwa wątki piszą, w taki sposób, że jakiś wiersz jest zapisywany przez wątek A przed wierszem przez wątek B, to wiersze niekoniecznie są zapisywane w tej kolejności. Może się nawet zdarzyć, że wątek zapisuje swoje wyjście, w tym samy czasie gdy drugi wątek zapisuje linię. W tej sytuacji pod Linuksem (być może) otrzymasz poprawne wyjście DebugLn(), a pod win32 możesz otrzymać wyjątek (prawdopodobnie DiskFull) z powodu użycia DebugLn() poza głównym wątkiem. Tak więc, aby uniknąć bólów głowy, użyj DebugLnThreadLog() wspomnianego poniżej.
448	444
449	445		Moduł LCLProc zawiera kilka funkcji, które pozwalają każdemu wątkowi zapisywać do własnego pliku dziennika:
450	446
451	447		``` pascal
452	448		procedure DbgOutThreadLog(const Msg: string); overload;
453	449		procedure DebuglnThreadLog(const Msg: string); overload;
454	450		procedure DebuglnThreadLog(Args: array of const); overload;
455	451		procedure DebuglnThreadLog; overload;
456	452		```
457	453
458	454		Na przykład: Zamiast writeln('Jakiś tekst', 123); użyj
459	455
460	456		` DebuglnThreadLog(['Jakiś tekst ',123]);`
461	457
462	458		Spowoduje to dodanie linii 'Jakiś tekst 123' do Log\<PID\>.txt, gdzie \<PID\> jest identyfikatorem procesu bieżącego wątku.
463	459
464	460		Dobrym pomysłem jest usunięcie plików dziennika przed każdym uruchomieniem:
465	461
466	462		` rm -f Log* && ./project1`
467	463
468	464		### Linux
469	465
470	466		Jeśli spróbujesz debugować aplikację wielowątkową w systemie Linux, będziesz miał jeden duży problem: Menedżer pulpitu na serwerze X może się zawiesić. Dzieje się tak na przykład, gdy aplikacja przechwyciła mysz/klawiaturę i została zatrzymana przez gdb, a serwer X czeka na twoją aplikację. Kiedy tak się stanie, możesz po prostu zalogować się z innego komputera i zabić gdb lub wyjść z tej sesji, naciskając CTRL+ALT+F3 i zabić gdb. Alternatywnie możesz ponownie uruchomić menedżera okien: wpisz sudo /etc/init.d/gdm restart. Spowoduje to ponowne uruchomienie menedżera pulpitu i powrót do pulpitu.
471	467
472	468		Ponieważ zależy to od tego, gdzie gdb zatrzymuje twój program, w niektórych przypadkach mogą pomóc pewne sztuczki: dla Ubuntu x64 ustaw opcje projektu do debugowania wymaganego dodatkowego pliku informacyjnego...
473	469
474	470		` Projekt -> Opcje projektu -> Opcje kompilatora -> Odpluskwianie, i zaznacz: Use external gdb debug symbols file (-Xg).`
475	471
476	472		Inną opcją jest otwarcie innego pulpitu X, uruchomienie IDE/gdb na jednym i aplikacji na drugim, tak aby zawieszał się tylko pulpit testowy. Utwórz nową instancję X za pomocą:
477	473
478	474		` X :1 &`
479	475
480	476		Gdy pulpit się otworzy, możesz przełączyć się na inny pulpit (ten, z którym pracujesz, naciskając CTRL + ALT + F7), będziesz mógł wrócić do nowego pulpitu graficznego za pomocą CTRL + ALT + F8 (jeśli ta kombinacja nie działa, spróbuj z CTRL + ALT + F2 ... ta kombinacja klawiszy działała w [Slackware](http://www.slackware.com)).
481	477
482	478		Następnie możesz, jeśli chcesz, utworzyć sesję pulpitu na X, za pomocą polecenia:
483	479
484	480		` gnome-session --display=:1 &`
485	481
486	482		Następnie w Lazarusie w oknie dialogowym parametrów uruchamiania projektu (Uruchom -\> Uruchom z parametrami -\> Ekran) zaznacz opcję „Użyj ekranu” i wpisz :1.
487	483
488	484		Teraz aplikacja będzie działać na drugim serwerze X i będziesz mógł ją debugować na pierwszym.
489	485
490	486		Zostało to przetestowane z Free Pascal 2.0 i Lazarus 0.9.10 w systemie Linux.
491	487
492	488		------------------------------------------------------------------------
493	489
494	490		Zamiast tworzyć nową sesję X, można użyć Xnest. Xnest to sesja X w oknie. Korzystanie z niego sprawia, że X serwer nie blokuje się podczas debugowania wątków i jest znacznie łatwiej debugować bez konieczności zmiany terminali.
495	491
496	492		Linia poleceń do uruchomienia Xnest to
497	493
498	494		` Xnest :1 -ac`
499	495
500	496		tworzy sesję X na :1 i wyłącza kontrolę dostępu.
501	497
502	498		## Interfejsy widżetów Lazarusa
503	499
504	500		Win32, gtk i interfejsy carbon obsługują wielowątkowość. Oznacza to, że działają tu TThread, krytyczne sekcje i Synchronize. Ale nie są bezpieczne wątkowo. To znaczy, że tylko jeden wątek na raz może uzyskać dostęp do LCL. Ponieważ główny wątek nigdy nie powinien czekać na kolejny wątek, to sprawia, że tylko wątek główny może uzyskać dostęp do LCL, czyli do wszystkiego, co ma związek z uchwytami TControl, Application i widgetów LCL. W LCL jest kilka funkcji bezpiecznych dla wątków. Na przykład większość funkcji w module FileUtil jest bezpieczna wątkowo.
505	501
506	502		### Użycie SendMessage/PostMessage do komunikacji pomiędzy wątkami
507	503
508	504		Tylko jeden wątek w aplikacji powinien wywoływać interfejsy API LCL, zwykle wątek główny. Inne wątki mogą korzystać z LCL za pomocą wielu metod pośrednich, jedną z dobrych opcji jest użycie SendMessage lub PostMessage. LCLIntf.SendMessage i LCLIntf.PostMessage wyślą wiadomość skierowaną do okna w puli wiadomości aplikacji.
509	505
510	506		Zobacz także dokumentację tych procedur:
511	507
512	508		- [[doc:lcl/lclintf/sendmessage.html\|SendMessage]]
513	509		- [[doc:lcl/lclintf/postmessage.html\|PostMessage]]
514	510
515	511		Różnica między SendMessage i PostMessage polega na sposobie, w jaki zwracają kontrolę do wątku wywołującego. Podobnie jak dla Synchronize, w SendMessage bloki i kontrola nie są zwracane, dopóki okno, do którego wiadomość została wysłana, nie skończy jej przetwarzać; jednak w pewnych okolicznościach SendMessage może próbować zoptymalizować przetwarzanie, pozostając w kontekście wątku, który go wywołał. Dzięki PostMessage kontrola jest zwracana natychmiast do określonej przez system maksymalnej liczby umieszczonych w kolejce wiadomości i tak długo, jak na stercie pozostaje miejsce na dołączane dane.
516	512
517	513		W obu przypadkach procedura obsługująca komunikat (patrz niżej) powinna unikać wywoływania application.ProcessMessages, ponieważ może to spowodować wysłanie drugiego komunikatu, który zostanie obsłużony ponownie. Jeśli jest to nieuniknione, prawdopodobnie lepiej byłoby użyć innego mechanizmu do przesyłania serializowanych zdarzeń między wątkami.
518	514
519	515		Oto przykład, w jaki wątek dodatkowy może wysłać tekst, który ma być wyświetlany w kontrolce LCL do wątku głównego:
520	516
521	517		``` pascal
522	518		const
523	519		WM_GOT_ERROR = LM_USER + 2004;
524	520		WM_VERBOSE = LM_USER + 2005;
525	521
526	522		procedure VerboseLog(Msg: string);
527	523		var
528	524		PError: PChar;
529	525		begin
530	526		if MessageHandler = 0 then Exit;
531	527		PError := StrAlloc(Length(Msg)+1);
532	528		StrCopy(PError, PChar(Msg));
533	529		PostMessage(formConsole.Handle, WM_VERBOSE, Integer(PError), 0);
534	530		end;
535	531		```
536	532
537	533		I przykład, jak obsłużyć tę wiadomość z okna:
538	534
539	535		``` pascal
540	536		const
541	537		WM_GOT_ERROR = LM_USER + 2004;
542	538		WM_VERBOSE = LM_USER + 2005;
543	539
544	540		type
545	541		{ TformConsole }
546	542
547	543		TformConsole = class(TForm)
548	544		DebugList: TListView;
549	545		// ...
550	546		private
551	547		procedure HandleDebug(var Msg: TLMessage); message WM_VERBOSE;
552	548		end;
553	549
554	550		var
555	551		formConsole: TformConsole;
556	552
557	553		implementation
558	554
559	555		....
560	556
561	557		{ TformConsole }
562	558
563	559		procedure TformConsole.HandleDebug(var Msg: TLMessage);
564	560		var
565	561		Item: TListItem;
566	562		MsgStr: PChar;
567	563		MsgPasStr: string;
568	564		begin
569	565		MsgStr := PChar(Msg.wparam);
570	566		MsgPasStr := StrPas(MsgStr);
571	567		Item := DebugList.Items.Add;
572	568		Item.Caption := TimeToStr(SysUtils.Now);
573	569		Item.SubItems.Add(MsgPasStr);
574	570		Item.MakeVisible(False);
575	571
576	572		// Po którym następuje coś takiego
577	573
578	574		TrayControl.SetError(MsgPasStr);
579	575		StrDispose(MsgStr)
580	576		end;
581	577
582	578		end.
583	579		```
584	580
585	581		## Sekcje krytyczne
586	582
587	583		Sekcja krytyczna to obiekt służący do upewnienia się, że jakaś część kodu jest wykonywana tylko przez jeden wątek na raz. Sekcja krytyczna musi zostać utworzona/zainicjowana, zanim będzie można jej użyć i zwolniona, gdy nie będzie już potrzebna.
588	584
589	585		Sekcje krytyczne zwykle są używane w ten sposób:
590	586
591	587		Deklaracja sekcji (globalnie dla wszystkich wątków, które powinny mieć dostęp do tej sekcji):
592	588
593	589		` MyCriticalSection: TRTLCriticalSection;`
594	590
595	591		Utworzenie sekcji:
596	592
597	593		` InitializeCriticalSection(MyCriticalSection);`
598	594
599	595		Uruchomienie kilka wątków. Robienie czegoś na wyłączność:
600	596
601	597		``` pascal
602	598		EnterCriticalSection(MyCriticalSection);
603	599		try
604	600		// uzyskaj dostęp do zmiennych, zapisz pliki, wyślij pakiety sieciowe itp.
605	601		finally
606	602		LeaveCriticalSection(MyCriticalSection);
607	603		end;
608	604		```
609	605
610	606		Po zakończeniu wszystkich wątków zwolnij sekcję krytyczną:
611	607
612	608		` DeleteCriticalSection(MyCriticalSection);`
613	609
614	610		Alternatywnie możesz użyć obiektu TCriticalSection. Inicjalizację wykonujemy przez jego utworzenie, metoda Enter wykonuje EnterCriticalSection, metoda Leave wykonuje LeaveCriticalSection, a zniszczenie obiektu powoduje jego usunięcie.
615	611
616	612		Należy zauważyć, że sekcja krytyczna nie chroni przed wprowadzeniem tego samego wątku do tego samego bloku kodu, tylko przed różnymi wątkami. Z tego powodu nie może służyć do ochrony m.in. przed ponownym wprowadzeniem do programu obsługi wiadomości (patrz sekcja wyżej).
617	613
618	614		Na przykład: 5 wątków zwiększających licznik. Zobacz lazarus/examples/multithreading/criticalsectionexample1.lpi
619	615
620	616		> Warning: Istnieją dwa zestawy powyższych czterech funkcji. Znajdują się w RTL i LCL. Te w LCL są zdefiniowane w modułach LCLIntf i LCLType. Oba działają prawie tak samo. Możesz używać obu jednocześnie w swojej aplikacji, ale nie powinieneś używać funkcji RTL w sekcji krytycznej LCL i na odwrót.
621	617
622	618		### Współdzielenie zmiennych
623	619
624	620		Jeśli niektóre wątki współdzielą zmienną, która jest tylko do odczytu, nie ma się czym martwić. Po prostu odczytaj jej wartość. Ale jeśli jeden lub kilka wątków zmienia wartość zmiennej, to musisz upewnić się, że tylko jeden wątek ma dostęp do tej zmiennej w danej chwili.
625	621
626	622		Na przykład: 5 wątków zwiększających licznik. Zobacz lazarus/examples/multithreading/criticalsectionexample1.lpi
627	623
628	624		## Oczekiwanie na inny wątek
629	625
630	626		Jeśli wątek A potrzebuje wyniku innego wątku B, musi on poczekać, aż B zakończy pracę.
631	627
632	628		Ważne: Główny wątek nigdy nie powinien czekać na kolejny wątek. Zamiast tego użyj opcji Synchronizuj (patrz wyżej).
633	629
634	630		Zobacz przykład: lazarus/examples/multithreading/waitforexample1.lpi
635	631
636	632		``` pascal
637	633		{ TThreadA }
638	634
639	635		procedure TThreadA.Execute;
640	636		begin
641	637		Form1.ThreadB:=TThreadB.Create(false);
642	638		// Utwórz zdarzenie
643	639		WaitForB:=RTLEventCreate;
644	640		while not Application.Terminated do begin
645	641		// czekaj w nieskończoność (aż B obudzi A)
646	642		RtlEventWaitFor(WaitForB);
647	643		writeln('A: ThreadB.Counter='+IntToStr(Form1.ThreadB.Counter));
648	644		end;
649	645		end;
650	646
651	647		{ TThreadB }
652	648
653	649		procedure TThreadB.Execute;
654	650		var
655	651		i: Integer;
656	652		begin
657	653		Counter:=0;
658	654		while not Application.Terminated do begin
659	655		// B: Pracuje ...
660	656		Sleep(1500);
661	657		inc(Counter);
662	658		// wybudza A
663	659		RtlEventSetEvent(Form1.ThreadA.WaitForB);
664	660		end;
665	661		end;
666	662		```
667	663
668	664		> Note: RtlEventSetEvent można wywołać przed RtlEventWaitFor. Wtedy RtlEventWaitFor natychmiast powróci. Użyj RLeventResetEvent, aby wyczyścić flagę.
669	665
670	666		## Wątek potomny, rozwidlenie (fork)
671	667
672	668		Podczas rozwidlenia w aplikacji wielowątkowej należy pamiętać, że wszelkie wątki utworzone i uruchomione PRZED wywołaniem fork (lub fpFork) NIE będą uruchomione w procesie potomnym. Jak stwierdzono na stronie podręcznika fork(), wszelkie wątki, które działały przed wywołaniem fork, będą miały stan niezdefiniowany.
673	669
674	670		Należy więc pamiętać o wszelkich wątkach inicjujących się przed wywołaniem fork (w tym w sekcji inicjowania). NIE będą działać.
675	671
676	672		## Procedury/pętle równoległe
677	673
678	674		Szczególnym przypadkiem wielowątkowości jest równoległe uruchamianie pojedynczej procedury. Zobacz [[Parallel procedures\|Procedury równoległe]].
679	675
680	676		## Obliczenia rozproszone
681	677
682	678		Następnym wyższym krokiem po wielowątkowości jest uruchamianie wątków na wielu komputerach.
683	679
684	680		- Do komunikacji można użyć jednego z pakietów TCP, takich jak synapse, lnet lub indy. Daje to maksymalną elastyczność i jest używane głównie w przypadku luźno połączonych aplikacji Klient/Serwer.
685	681		- Możesz użyć bibliotek przekazujących komunikaty, takich jak [[MPICH]], które są używane do HPC (High Performance Computing) w klastrach.
686	682
687	683		## Wątki zewnętrzne
688	684
689	685		Aby system wątków Free Pascal działał poprawnie, każdy nowo utworzony wątek FPC musi zostać zainicjowany (dokładniej muszą być zainicjowane: wyjątek, system I/O i system zmiennych dla wątków, aby działały zmienne wątków i stos). Jest to wykonywane w pełni automatycznie, jeśli używasz BeginThread (lub pośrednio za pomocą klasy TThread). Jeśli jednak używasz wątków, które zostały utworzone bez BeginThread (tj. wątków zewnętrznych), może być wymagana dodatkowa praca (obecnie). Wątki zewnętrzne obejmują również te, które zostały utworzone w zewnętrznych bibliotekach C (.DLL/.so).
690	686
691	687		Kwestie do rozważenia podczas korzystania z wątków zewnętrznych (mogą nie być potrzebne we wszystkich lub przyszłych wersjach kompilatora):
692	688
693	689		- Nie używaj w ogóle wątków zewnętrznych - używaj wątków FPC. Jeśli możesz uzyskać kontrolę nad sposobem tworzenia wątku, utwórz wątek samodzielnie za pomocą BeginThread.
694	690
695	691		Jeśli konwencja wywoływania nie pasuje (np. jeśli oryginalna funkcja wątku wymaga konwencji wywoływania cdecl, ale BeginThread wymaga konwencji Pascala, utwórz rekord, w którym przechowasz oryginalną wymaganą funkcję wątku i wywołaj tę funkcję w funkcji wątku Pascala:
696	692
697	693		``` pascal
698	694		type
699	695		TCdeclThreadFunc = function (user_data:Pointer):Pointer;cdecl;
700	696
701	697		PCdeclThreadFuncData = ^TCdeclThreadFuncData;
702	698		TCdeclThreadFuncData = record
703	699		Func: TCdeclThreadFunc; //funkcja cdecl
704	700		Data: Pointer; //oryginalne dane
705	701		end;
706	702
707	703		// Wątek Pascala wywołuje funkcję cdecl
708	704		function C2P_Translator(FuncData: pointer) : ptrint;
709	705		var
710	706		ThreadData: TCdeclThreadFuncData;
711	707		begin
712	708		ThreadData := PCdeclThreadFuncData(FuncData)^;
713	709		Result := ptrint(ThreadData.Func(ThreadData.Data));
714	710		end;
715	711
716	712		procedure CreatePascalThread;
717	713		var
718	714		ThreadData: PCdeclThreadFuncData;
719	715		begin
720	716		New(ThreadData);
721	717		// to jest pożądana funkcja wątku cdecl
722	718		ThreadData^.Func := func;
723	719		ThreadData^.Data := user_data;
724	720		// to tworzy wątek Pascala
725	721		BeginThread(@C2P_Translator, ThreadData );
726	722		end;
727	723		```
728	724
729	725		- Zainicjuj system wątków FPC, tworząc fikcyjny wątek. Jeśli nie utworzysz żadnego wątku Pascala w swojej aplikacji, system wątków nie zostanie zainicjowany (a zatem zmienne wątków nie będą działać, a zatem i stos nie będzie działać poprawnie).
730	726
731	727		``` pascal
732	728		type
733	729		tc = class(tthread)
734	730		procedure execute;override;
735	731		end;
736	732
737	733		procedure tc.execute;
738	734		begin
739	735		end;
740	736
741	737		{ main program }
742	738		begin
743	739		{ zainicjować system wątków }
744	740		with tc.create(false) do
745	741		begin
746	742		waitfor;
747	743		free;
748	744		end;
749	745		{ ... Twój kod wykonywany dalej }
750	746		end.
751	747		```
752	748
753	749		(Po zainicjowaniu systemu wątków środowisko wykonawcze może ustawić zmienną systemową „IsMultiThread” na wartość true, która jest używana przez procedury FPC do wykonywania blokad tu i tam. Nie należy ustawiać tej zmiennej ręcznie.)
754	750
755	751		- Jeśli z jakiegoś powodu to nie działa, wypróbuj ten kod w funkcji wątku zewnętrznego:
756	752
757	753		``` pascal
758	754		function ExternalThread(param: Pointer): LongInt; stdcall;
759	755		var
760	756		tm: TThreadManager;
761	757		begin
762	758		GetThreadManager(tm);
763	759		tm.AllocateThreadVars;
764	760		InitThread(1000000); // dostosuj tutaj początkowy rozmiar stosu
765	761
766	762		{ zrób tutaj coś w wątku ... }
767	763
768	764		Result:=0;
769	765		end;
770	766		```
771	767
772	768		### Identyfikacja wątków zewnętrznych
773	769
774	770		Czasami nawet nie wiesz, czy masz do czynienia z wątkami zewnętrznymi (np. czy jakaś biblioteka C wykonuje wywołanie zwrotne). To może pomóc w analizie takiej sytuacji:
775	771
776	772		1\. Zapytaj system operacyjny o identyfikator bieżącego wątku podczas uruchamiania aplikacji
777	773
778	774		``` pascal
779	775		GetCurrentThreadID() //windows;
780	776		GetThreadID() //Darwin/macOS;
781	777		TThreadID(pthread_self) //Linux;
782	778		```
783	779
784	780		2\. Zapytaj ponownie o identyfikator bieżącego wątku wewnątrz funkcji wątku i porównaj to z wynikiem kroku 1.
785	781
786	782		### Dodawanie opóźnień czasowych
787	783
788	784		ThreadSwitch()
789	785
790	786		> Note: Nie używaj sztuczki z uśpieniem w Windows Sleep(0) ponieważ nie będzie to działać na wszystkich platformach.
791	787
792	788		## Zobacz także
793	789
794	790		- [[Streaming components\|Komponenty strumieniowe]]
795	791		- [[Manager Worker Threads System\|System nadzorowania wątków roboczych]]
796	792		- [[Example of multi-threaded application: array of threads/pl\|Przykład aplikacji wielowątkowej: tablicy wątków]]
797	793		- [[Parallel procedures\|Procedury równoległe]]
798	794		- [[Main Loop Hooks\|Petla gówna uchwytów]]
799	795		- [[Asynchronous Calls\|Wywołanie asynchroniczne]]
800	796		- [Mutlithreading - The Delphi way](http://nickhodges.com/MultiThreadingInDelphi/ToC.html)
801	797
802	798		---
803	799		From the Free Pascal wiki, page "Multithreaded Application Tutorial/pl", as it stood on 2023-09-23 after a change by Slawek, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history