|
class methods
|
|
abort_on_exception
|
Thread.abort_on_exception
-> true oder false |
|
Gibt den Status der globalen ``abort on exception''-Bedingung zurück. Der Standardwert in
false.
Wenn der Wert auf true gesetzt ist, werden alle Threads beendet (der
Prozess führt exit(0) aus) wenn eine Exception in irgendeinem Thread geworfen wird.
Siehe auch Thread.abort_on_exception=.
|
|
abort_on_exception=
|
Thread.abort_on_exception=
einBoolean-> true oder false |
|
Wenn true gesetzt wird, beenden alle Threads die Ausführung wenn eine
Exception auftritt. Die Methode gibt den neu gesetzten Wert zurück.
Thread.abort_on_exception = true
t1 = Thread.new do
puts "In second thread"
raise "Raise exception"
end
t1.join
print "not reached\n"
|
ergibt:
In second thread
prog.rb:4: Raise exception (RuntimeError)
from prog.rb:2:in `initialize'
from prog.rb:2:in `new'
from prog.rb:2
|
|
|
critical
|
Thread.critical
-> true oder false |
|
Gibt den Status der globalen ``thread critical''-Bedingung zurück.
|
|
critical=
|
Thread.critical= einBoolean-> true oder false |
|
Setzt den Status der globalen ``thread critical''-Bedingung und gibt diesen zurück.
Das Setzen des Status auf true, verhindert, dass eixistierende Threads zur
Ausführung disponiert werden. Dies blockiert nicht die Erstellung und Ausführung von neuen
Threads. Bestimmte Thread-Operationen (wie z.B. das Stoppen oder ``Abschiessen'' eines Thread,
das In-Schlaf-setzen des aktuellen Threads sowie das Werfen von Fehlern) können dazu führen, dass
ein Thread auch in einem kritischen Abschnitt ausgeführt wird.
count=0
Thread.new { while true; sleep(1); print "a "; count+=1; end }
while count < 3 do end # no-op wait
Thread.critical = true
puts "no more a's will come out."
|
ergibt:
a a a no more a's will come out.
|
|
|
current
|
Thread.current
-> einThread |
|
Gibt den derzeit ausgeführten Thread zurück.
Thread.current |
» |
#<Thread:0x40196528 run> |
|
|
exit
|
Thread.exit
|
|
Beendet den derzeit ausgeführten Thread und setzt einen anderen zur Ausführung an. Wenn dieser
Thread bereits zum ``Abschuss'' markiert ist, gibt exit den Thread
zurück. Wenn dies der Haupt-Thread oder der letzte Thread ist, wird der Prozess beendet.
|
|
fork
|
Thread.fork { block }-> einThread |
|
Synonym für Thread.new.
|
|
kill
|
Thread.kill( einThread )
|
|
Veranlasst, dass der aktuelle Thread beendet wird (see Thread.exit).
count = 0 |
a = Thread.new { while true do count += 1 end } |
sleep(1) |
» |
1 |
Thread.kill(a) |
» |
#<Thread:0x4018d52c dead> |
count |
» |
911276 |
a.alive? |
» |
false |
|
|
list
|
Thread.list -> einArray |
|
Gibt ein Array mit allen Thread-Objekten, die entweder ausführbar
oder gestoppt sind, zurück.
Thread.new { sleep(200) } |
Thread.new { 1000000.times {|i| i*i } } |
Thread.new { Thread.stop } |
l = Thread.list |
l |
» |
[#<Thread:0x4018d658 sleep>, #<Thread:0x4018d6d0 run>, #<Thread:0x4018d70c sleep>, #<Thread:0x40196528 run>] |
|
|
main
|
Thread.main
-> einThread |
|
Gibt den Haupt-Thread des Prozesses zurück.
Thread.main |
» |
#<Thread:0x40196528 run> |
|
|
new
|
Thread.new( [arg]* ) {| args | block }-> einThread |
|
Erstellt einen neuen Thread, in dem die Anweisungen im Codeblock ausgeführt werden, und beginnt
dessen Ausführung. Etwaige Argumente für Thread.new
werden an den Codeblock weitergegeben.
x = Thread.new { sleep .1; print "x"; print "y"; print "z" }
a = Thread.new { print "a"; print "b"; sleep .2; print "c" }
x.join # Let the threads finish before
a.join # main thread exits...
|
ergibt:
|
|
pass
|
Thread.pass
|
|
Ruft den Thread-Scheduler auf, um die Ausführung an einen anderen Thread weiterzugeben.
a = Thread.new { print "a"; Thread.pass;
print "b"; Thread.pass;
print "c" }
b = Thread.new { print "x"; Thread.pass;
print "y"; Thread.pass;
print "z" }
a.join
b.join
|
ergibt:
|
|
start
|
Thread.start( [args]* ) {| args | block }-> einThread |
|
Im Grunde gleich mit Thread.new.
Wenn allerdings Thread abgeleitet ist, ruft die start-Methode
der abgeleiteten Klasse nicht die zugehörige initialize-Methode der Unterklasse
auf.
|
|
stop
|
Thread.stop
|
|
Stoppt die Ausführung des aktuellen Threads und versetzt es in einen ``Schlafmodus''. Die
Ausführung eines anderen Threads wird angesetzt. Die Methode setzt die ``critical''-Bedingung
zurück auf false.
a = Thread.new { print "a"; Thread.stop; print "c" }
Thread.pass
print "b"
a.run
a.join
|
ergibt:
|
|
instance methods
|
|
[ ]
|
thr[ einSymbol ] -> einObjekt oder nil |
|
Attributreferenz---Gibt den Wert einer lokalen Thread-Variable zurück, die entweder als
Symbol oder als String-Name übergeben wird. Wenn die angegebene Variable nicht existiert
wird nil zurück gegeben.
a = Thread.new { Thread.current["name"] = "A"; Thread.stop }
b = Thread.new { Thread.current[:name] = "B"; Thread.stop }
c = Thread.new { Thread.current["name"] = "C"; Thread.stop }
Thread.list.each {|x| print x.inspect, x[:name], "\n" }
|
ergibt:
#<Thread:0x4018d3ec sleep>C
#<Thread:0x4018d43c sleep>B
#<Thread:0x4018d4a0 sleep>A
#<Thread:0x40196528 run>nil
|
|
|
[ ]=
|
thr[ einSymbol ] = einObjekt-> einObjekt
|
|
Attributzuweisung---Setzt oder erstellt den Wert einer lokale Thread-Variable, deren Name als
Symbol oder String übergeben wird. Siehe auch
Thread#[].
|
|
abort_on_exception
|
thr.abort_on_exception
-> true oder false |
|
Gibt den Status der ``abort on exception''-Bedingung für thr zurück. Der
Standardwert ist false.
Siehe auch Thread.abort_on_exception=.
|
|
abort_on_exception=
|
thr.abort_on_exception=
true oder false-> true oder false |
|
Wenn der Wert true zugewiesen ist, werden alle Threads (inklusive des
Haupt-Programms) gezwungen, sich zu beenden, wenn eine Exception in thr geworfen
wird. Der Prozess wird tatsächlich mit exit(0) beendet.
|
|
alive?
|
thr.alive?
-> true oder false |
|
Gibt true zurück, wenn thr läuft oder schläft.
Thread.current.alive? |
» |
true |
|
|
exit
|
thr.exit -> thr oder nil |
|
Beendet thr und setzt einen anderen Thread zur Ausführung an. Wenn dieser Thread
bereits zum ``Abschuss'' markiert ist, gibt exit das Thread-Objekt
zurück. Wenn diese Methode am Haupt-Thread oder am letzten Thread aufgerufen wird, wird der
Prozess beendet.
|
|
join
|
thr.join
-> thr |
|
Der aufrufende Thread unterbricht seine Ausführung und ruft thr auf. Endet nicht, bevor
thr beendet ist. Threads, die nicht angebunden sind, werden bei Beendigung des
Hauptprogramms ``abgeschossen''.
a = Thread.new { print "a"; sleep(10); print "b"; print "c" }
x = Thread.new { print "x"; Thread.pass; print "y"; print "z" }
x.join # Let x thread finish, a will be killed on exit.
|
ergibt:
|
|
key?
|
thr.key?( einSymbol ) -> true oder false
|
|
Gibt true zurück, wenn der angegebene String (oder Symbol) als lokale
Thread-Variable existiert.
me = Thread.current |
me[:oliver] = "a" |
me.key?(:oliver) |
» |
true |
me.key?(:stanley) |
» |
false |
|
|
kill
|
thr.kill
|
|
Synonym für Thread#exit.
|
|
priority
|
thr.priority
-> einInteger |
|
Gibt die Priorität von thr zurück. Standardwert ist Null; Threads mit höherer
Priorität laufen vor Threads mit niedriger Priorität.
Thread.current.priority |
» |
0 |
|
|
priority=
|
thr.priority= einInteger-> thr |
|
Setzt die Priorität von thr auf einInteger. Threads mit höherer
Priorität laufen vor Threads mit niedriger Priorität.
count1 = count2 = 0
a = Thread.new do
loop { count1 += 1 }
end
a.priority = -1
|
b = Thread.new do |
loop { count2 += 1 } |
end |
b.priority = -2 |
sleep 1 |
» |
1 |
Thread.critical = 1 |
count1 |
» |
619920 |
count2 |
» |
11586 |
|
|
raise
|
thr.raise( eineException )
|
|
Wirft eine Exception (vgl. Kernel::raise
in diesem Kapitel im Abschnitt ``Module'' unter ``Kernel'') in thr.
Der Aufrufer muss nicht thr sein.
Thread.abort_on_exception = true
a = Thread.new { sleep(200) }
a.raise("Gotcha")
|
ergibt:
prog.rb:3: Gotcha (RuntimeError)
from prog.rb:2:in `initialize'
from prog.rb:2:in `new'
from prog.rb:2
|
|
|
run
|
thr.run -> thr |
|
Weckt thr und macht es für den Scheduler verfügbar. Wenn der Aufruf nicht in
einem kritischen Abschnitt erfolgt, wird der Scheduler aufgerufen.
a = Thread.new { puts "a"; Thread.stop; puts "c" }
Thread.pass
puts "Got here"
a.run
a.join
|
ergibt:
|
|
safe_level
|
thr.safe_level
-> einInteger |
|
Gibt den in thr gesetzten Sicherheitslevel zurück.
Thread.current.safe_level |
» |
0 |
|
|
status
|
thr.status
-> einString, false oder nil |
|
Gibt den Status von thr zurück: ``sleep'', wenn thr schläft
oder auf I/O wartet, ``run'' wenn thr ausgeführt wird, false
wenn thr normal bzw. nil wenn thr mit einer Exception beendet
wurde.
a = Thread.new { raise("die now") } |
b = Thread.new { Thread.stop } |
c = Thread.new { Thread.exit } |
a.status |
» |
nil |
b.status |
» |
"sleep" |
c.status |
» |
false |
Thread.current.status |
» |
"run" |
|
|
stop?
|
thr.stop?
-> true oder false |
|
Gibt true zurück, wenn thr tot ist oder gerade schläft.
a = Thread.new { Thread.stop } |
b = Thread.current |
a.stop? |
» |
true |
b.stop? |
» |
false |
|
|
value
|
thr.value
-> einObjekt |
|
Wartet darauf, dass thr abläuft (über Thread#join)
und gibt dessen Wert zurück.
a = Thread.new { 2+2 } |
a.value |
» |
4 |
|
|
wakeup
|
thr.wakeup
-> thr |
|
Markiert thr als für den Scheduler verfügbar (obwohl es immer noch durch I/O
blockiert sein kann). Ruft den Scheduler aber nicht auf (vgl.
Thread#run).
c = Thread.new { Thread.stop; puts "hey!" }
c.wakeup
|
ergibt:
|