Ruby multithreading

Setiap program yang dijalankan pada sistem adalah satu proses. Setiap proses mengandungi satu atau lebih utas.

Benang ialah proses kawalan berjujukan tunggal dalam program Menjalankan berbilang benang pada masa yang sama untuk menyelesaikan tugasan yang berbeza dalam satu program dipanggil berbilang benang.

Dalam Ruby, kita boleh mencipta berbilang benang melalui kelas Benang Ruby adalah ringan dan boleh melaksanakan kod selari dengan cara yang cekap.

Buat utas Ruby

Untuk memulakan utas baharu, cuma panggil Thread.new:

# 线程 #1 代码部分
Thread.new {
  # 线程 #2 执行代码
}
# 线程 #1 执行代码

Instance

Contoh berikut Menunjukkan cara untuk gunakan multi-threading dalam program Ruby:

#!/usr/bin/ruby

def func1
   i=0
   while i<=2
      puts "func1 at: #{Time.now}"
      sleep(2)
      i=i+1
   end
end

def func2
   j=0
   while j<=2
      puts "func2 at: #{Time.now}"
      sleep(1)
      j=j+1
   end
end

puts "Started At #{Time.now}"
t1=Thread.new{func1()}
t2=Thread.new{func2()}
t1.join
t2.join
puts "End at #{Time.now}"

Hasil pelaksanaan kod di atas ialah:

Started At Wed May 14 08:21:54 -0700 2014
func1 at: Wed May 14 08:21:54 -0700 2014
func2 at: Wed May 14 08:21:54 -0700 2014
func2 at: Wed May 14 08:21:55 -0700 2014
func1 at: Wed May 14 08:21:56 -0700 2014
func2 at: Wed May 14 08:21:56 -0700 2014
func1 at: Wed May 14 08:21:58 -0700 2014
End at Wed May 14 08:22:00 -0700 2014

Kitaran hayat thread

1 , Thread boleh dibuat menggunakan Thread.new, dan thread juga boleh dibuat menggunakan tiga kaedah Thread.start atau Thread.fork dengan sintaks yang sama.

2. Tidak perlu memulakan utas selepas menciptanya, utas akan dilaksanakan secara automatik.

3. Kelas Thread mentakrifkan beberapa kaedah untuk mengawal utas. Benang melaksanakan blok kod dalam Thread.new.

4. Pernyataan terakhir dalam blok kod utas ialah nilai utas, yang boleh dipanggil melalui kaedah utas Jika pelaksanaan utas selesai, nilai utas akan dikembalikan, jika tidak, nilainya tidak akan dikembalikan sehingga pelaksanaan benang selesai.

5. Kaedah Thread.current mengembalikan objek yang mewakili urutan semasa. Kaedah benang.utama mengembalikan benang utama.

6. Jalankan utas melalui kaedah Thread.Join Kaedah ini akan menangguhkan utas utama sehingga utas semasa menyelesaikan pelaksanaan.

Status utas

Benang mempunyai 5 keadaan:

Benang dan pengecualian

Apabila pengecualian berlaku dalam utas dan tidak ditangkap oleh penyelamatan, utas biasanya akan ditamatkan tanpa amaran. Walau bagaimanapun, jika utas lain telah menunggu untuk utas ini kerana Thread#join, utas menunggu juga akan dilemparkan pengecualian yang sama.

begin
  t = Thread.new do
    Thread.pass    # 主线程确实在等join
    raise "unhandled exception"
  end
  t.join
rescue
  p $!  # => "unhandled exception"
end

Gunakan 3 kaedah berikut untuk membenarkan penterjemah mengganggu apabila urutan ditamatkan kerana pengecualian.

• Nyatakan pilihan -d apabila memulakan skrip dan jalankannya dalam mod nyahpepijat.

• Tetapkan bendera dengan Thread.abort_on_exception.

• Gunakan Thread#abort_on_exception untuk menetapkan bendera bagi urutan yang ditentukan.

Apabila salah satu daripada 3 kaedah di atas digunakan, keseluruhan jurubahasa akan terganggu.

t = Thread.new { ... }
t.abort_on_exception = true

Kawalan penyegerakan benang

Dalam Ruby, tiga cara untuk mencapai penyegerakan disediakan, iaitu:

1. Penyegerakan benang melalui kelas Mutex

2. Kelas Queue yang menyelia pemindahan data merealisasikan penyegerakan benang

3 Gunakan ConditionVariable untuk merealisasikan kawalan penyegerakan

Penyegerakan thread direalisasikan melalui kelas Mutex

Ia adalah. direalisasikan melalui kawalan penyegerakan Benang kelas Mutex, jika pembolehubah program diperlukan dalam berbilang utas pada masa yang sama, pembolehubah ini boleh dikunci sebahagiannya menggunakan kunci. Kodnya adalah seperti berikut:

#!/usr/bin/ruby

require "thread"
puts "Synchronize Thread"

@num=200
@mutex=Mutex.new

def buyTicket(num)
     @mutex.lock
          if @num>=num
               @num=@num-num
               puts "you have successfully bought #{num} tickets"
          else
               puts "sorry,no enough tickets"
          end
     @mutex.unlock
end

ticket1=Thread.new 10 do
     10.times do |value|
     ticketNum=15
     buyTicket(ticketNum)
     sleep 0.01
     end
end

ticket2=Thread.new 10 do
     10.times do |value|
     ticketNum=20
     buyTicket(ticketNum)
     sleep 0.01
     end
end

sleep 1
ticket1.join
ticket2.join

Hasil pelaksanaan kod di atas ialah:

Synchronize Thread
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
you have successfully bought 20 tickets
you have successfully bought 15 tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets
sorry,no enough tickets

Selain menggunakan kunci untuk mengunci pembolehubah, anda juga boleh gunakan try_lock untuk mengunci pembolehubah, dan anda juga boleh menggunakan Mutex menyegerakkan akses kepada pembolehubah.

Kelas Baris Gilir yang menyelia pemindahan data melaksanakan penyegerakan benang

Kelas Baris Gilir mewakili baris gilir yang menyokong urutan dan boleh mengakses penghujung baris gilir secara serentak. Urutan yang berbeza boleh menggunakan kelas pasangan yang sama, tetapi anda tidak perlu risau sama ada data dalam baris gilir ini boleh disegerakkan Selain itu, menggunakan kelas SizedQueue boleh mengehadkan panjang baris gilir

The SizedQueue. kelas boleh membantu kami membangunkan aplikasi penyegerakan benang. Program ini tidak perlu risau tentang penyegerakan benang selagi ia menyertai baris gilir ini.

Masalah pengeluar-pengguna klasik:

#!/usr/bin/ruby

require "thread"
puts "SizedQuee Test"

queue = Queue.new

producer = Thread.new do
     10.times do |i|
          sleep rand(i) # 让线程睡眠一段时间
          queue << i
          puts "#{i} produced"
     end
end

consumer = Thread.new do
     10.times do |i|
          value = queue.pop
          sleep rand(i/2)
          puts "consumed #{value}"
     end
end

consumer.join

Output program:

SizedQuee Test
0 produced
1 produced
consumed 0
2 produced
consumed 1
consumed 2
3 produced
consumed 34 produced

consumed 4
5 produced
consumed 5
6 produced
consumed 6
7 produced
consumed 7
8 produced
9 produced
consumed 8
consumed 9

Pembolehubah benang

Benang boleh mempunyai pembolehubah peribadinya sendiri Pembolehubah peribadi utas ditulis pada utas apabila utas dibuat. Boleh digunakan dalam skop utas, tetapi tidak boleh dikongsi di luar utas.

Tetapi kadangkala, apakah yang perlu saya lakukan jika pembolehubah setempat sesuatu utas perlu diakses oleh utas lain atau utas utama? Ruby menyediakan cara untuk mencipta pembolehubah benang mengikut nama, sama seperti merawat benang sebagai jadual cincang. Tulis data melalui []= dan baca data melalui []. Mari kita lihat kod berikut:

#!/usr/bin/ruby

count = 0
arr = []

10.times do |i|
   arr[i] = Thread.new {
      sleep(rand(0)/10.0)
      Thread.current["mycount"] = count
      count += 1
   }
end

arr.each {|t| t.join; print t["mycount"], ", " }
puts "count = #{count}"

Hasil keluaran kod di atas ialah:

8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10

Benang utama menunggu sub-benang menyelesaikan pelaksanaan, dan kemudian mengeluarkan setiap nilai secara berasingan. .

Keutamaan utas

Keutamaan utas ialah faktor utama yang mempengaruhi penjadualan utas. Faktor lain termasuk tempoh masa pelaksanaan yang diduduki oleh CPU, penjadualan kumpulan benang, dsb.

Anda boleh menggunakan kaedah Thread.priority untuk mendapatkan keutamaan thread dan kaedah Thread.priority= untuk melaraskan keutamaan thread.

Keutamaan utas ialah 0 secara lalai. Mereka yang mempunyai keutamaan yang lebih tinggi melaksanakan lebih cepat.

A Thread boleh mengakses semua data dalam skopnya sendiri, tetapi apakah yang perlu anda lakukan jika anda perlu mengakses data daripada thread lain dalam thread? Kelas Thread menyediakan kaedah untuk data thread untuk mengakses satu sama lain Anda hanya boleh menggunakan thread sebagai jadual Hash Anda boleh menggunakan []= untuk menulis data dan [] untuk membaca data dalam mana-mana thread.

athr = Thread.new { Thread.current["name"] = "Thread A"; Thread.stop }
bthr = Thread.new { Thread.current["name"] = "Thread B"; Thread.stop }
cthr = Thread.new { Thread.current["name"] = "Thread C"; Thread.stop }
Thread.list.each {|x| puts "#{x.inspect}: #{x["name"]}" }

Seperti yang anda lihat, dengan menganggap urutan sebagai jadual Hash dan menggunakan kaedah [] dan []=, kami menyedari perkongsian data antara urutan.

Pengecualian bersama benang

Mutex (Mutal Exclusion = mutex lock) ialah sejenis kunci yang digunakan dalam pengaturcaraan berbilang benang untuk menghalang dua utas daripada mengakses sumber awam yang sama (seperti pembolehubah global) pada masa yang sama ) mekanisme untuk membaca dan menulis.

Instance tanpa Mutax

#!/usr/bin/ruby
require 'thread'

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      count1 += 1
      count2 += 1
   end
end
spy = Thread.new do
   loop do
      difference += (count1 - count2).abs
   end
end
sleep 1
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

Hasil keluaran dari contoh di atas ialah:

count1 :  9712487
count2 :  12501239
difference : 0

Instance menggunakan Mutax

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      mutex.synchronize do
         count1 += 1
         count2 += 1
      end
    end
end
spy = Thread.new do
   loop do
       mutex.synchronize do
          difference += (count1 - count2).abs
       end
   end
end
sleep 1
mutex.lock
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

Hasil output dari contoh di atas ialah :

count1 :  1336406
count2 :  1336406
difference : 0

Kebuntuan

Dua atau lebih unit pengkomputeran, kedua-dua pihak menunggu yang lain untuk berhenti berjalan untuk mendapatkan sumber sistem, tetapi apabila tidak ada pihak yang keluar awal, keadaan ini adalah. dipanggil kebuntuan.

Sebagai contoh, proses p1 menduduki monitor dan mesti menggunakan pencetak pada masa yang sama, dan pencetak diduduki oleh proses p2, dan p2 mesti menggunakan monitor, sekali gus membentuk kebuntuan.

Kita perlu memberi perhatian kepada kebuntuan benang apabila menggunakan objek Mutex.

Instance

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

cv = ConditionVariable.new
a = Thread.new {
   mutex.synchronize {
      puts "A: I have critical section, but will wait for cv"
      cv.wait(mutex)
      puts "A: I have critical section again! I rule!"
   }
}

puts "(Later, back at the ranch...)"

b = Thread.new {
   mutex.synchronize {
      puts "B: Now I am critical, but am done with cv"
      cv.signal
      puts "B: I am still critical, finishing up"
   }
}
a.join
b.join

Hasil keluaran contoh di atas ialah:

A: I have critical section, but will wait for cv
(Later, back at the ranch...)
B: Now I am critical, but am done with cv
B: I am still critical, finishing up
A: I have critical section again! I rule!

Kaedah kelas thread

Kaedah kelas Thread yang lengkap adalah seperti berikut:

Kaedah instantiation thread

Contoh berikut memanggil kaedah instantiation thread join:

#!/usr/bin/ruby

thr = Thread.new do   # 实例化
   puts "In second thread"
   raise "Raise exception"
end
thr.join   # 调用实例化方法 join

Berikut ialah senarai lengkap kaedah instantiation: