
Turkish: 
Birden fazla işlemciniz varsa, bu da birden fazla çekirdek sanal çekirdeği
içinde
varsayımsal olarak algoritmanızı veya üzerinde çalıştırmak istediğiniz çok çekirdekli bir işlemci
Birden çok CPU örneği böylelikle ayırmanız gerekir ve işletim sistemi tüm bu farklı örnekleri kontrol etmenin bir yolunu bulmalıdır.
aslında hala tek bir işlemciden faydalanabilirsiniz
Sisteminiz, programınızın bir kısmının şebeke girişi demek için beklediği zamanlar olabileceği için
başka bir işlem ipliği
Bir şey yapmak
Öyleyse, işletim sisteminin ne gördüğünü düşünerek başlayalım.
Bir program çalıştırırken, buna süreç denir ve bunun bir dizi talimatı vardır.
Bunu yürütmek programdır, aslında işletim sisteminin bir parçası değildir, programdır ancak içeride olduğumuzu bilmesi gerekir.
Öyle ki program öyle diyor ki

English: 
If you've got multiple processors either that's multiple cores virtual cores
in a
hypothetically a multi-core processor you want to run your algorithm or on
Multiple CPU instances so you need to split it up and the operating system needs to find some way of controlling all those different instances
actually you can still be beneficial on a single CPU
system because it might be times where part of your program is waiting for say network input so the operators will then schedule it in
another thread of execution
To do something
So let's start by thinking about what the operating system sees
when it's running a program and this is what's called a process and that's got a series of instructions and it's going to be
Executing this is the program this is actually not part of the operating system is it's the program but it needs to know we're inside
The program that is so that instruction say

Turkish: 
Ancak, işletim sisteminin benzer bir işlemi takip etmesi gereken başka bilgiler de var.
açık dosyaların listesi
Sanal hafızanız varsa hafızanın yapılandırılması
dahil veya
Çağrı sistemi, işletim sisteminin her birinin izini sürmesi için ihtiyaç duyduğu çeşitli şeyler var ve daha sonra çalıştırabilirsiniz.
aynı anda birden fazla işlem
bu yüzden programınızı birden fazla parçaya ayırabilmenizin bir yolu aslında çalışan birden fazla işlemi gerçekleştirmektir.
Bir süre insanlar bunu yaptılar.
Komutu UNIX'te bir fonksiyon kullanacak, örneğin çatal olarak adlandırdığınız programı, programı 1/2 olarak
diğeri yeni bir işlem tanımlayıcısına sahip olacaktı ve işletim sistemi bu bloğu kopyalayacaktı ve
Hangi hafızanın yeni bir listesini kullandığına dair yeni bir liste oluşturun, şimdi açtıkları dosyaların bir listesi
 
aynı blok hafıza tahsisatlarını ve diğer şeyleri dosyalar, böylece bir hafıza konumunu değiştirirseniz diğer tarafta güncellenir ve eğer
Bir dosya koltuğunu bir dosyanın farklı bir yerine değiştirdiniz, örneğin diğerlerinde güncelleyecektir.

English: 
But there's, also lots of other information that the operating system needs to keep track for a process a things like
list of open files
Configuration of memory and so on if you've got virtual memory
involved or
Paging there's various things that the operating system needs to keep track each of them has got a unique ID and you can then run
multiple processes at the same time
so one way you could break your program up into multiple chunks is to actually have multiple processes running in
for a while people did this they sort of
Will use the command a function in UNIX for example called fork you would split the program into 1/2 which would run off as
it was the other would have a new process identifier and the operating system would copy that block and
Create a new list of what memory uses a new list of the files they had open now these are point back to the same
 
files the same blocks memory allocations and things so that if you change one memory location it updated on the other side and things if
You changed a file seat to a different part of a file for example it would update in the others but

English: 
They would be separate processes and they'd have to have all the storage required to do that and that worked but
if you're breaking your program up so you can run your task on multiple CPUs
most of them are going to have the same list of files the same memory configuration the
Everything else that the operating system needs to keep track of the only thing that's going to be different is
Where it is in the program what bit of code is running from what part and so the idea that came along was ok let's
Have something lighter weight than a process and they called it a thread because you've got your thread of execution through the instructions
And what we have is that each process will have at least one thread of execution but could have many
So you have multiple threads of execution in your program so your programs running one thread
Which it starts off with that will then create another thread
Which does something and then another thread pratik and so on can do different parts they made last for the whole length of the program
they
may only last for a short part while that task being completed and so on
You may have multiple ones that get jobs from different things and so on how you structure your program

Turkish: 
Ayrı süreçler olacaklardı ve bunun için gerekli tüm depoya sahip olmalıydı ve bu işe yaradı.
Eğer programınızı bozuyorsanız, görevinizi birden fazla CPU'da çalıştırabilirsiniz.
çoğu aynı dosya listesine sahip olacak, aynı hafıza yapılandırmasına
İşletim sisteminin farklı olacak tek şeyi takip etmesi gereken her şey
Programın neresinde, hangi kısımdan hangi kod parçasının çalıştığı ve bu yüzden ortaya çıkan fikir tamam oldu.
Bir işlemden daha hafif bir şeye sahip olun, buna bir iş parçacığı dediler, çünkü talimatlar yoluyla yürütme iş parçanıza sahipsin.
Ve sahip olduğumuz şey, her sürecin en az bir yürütme iş parçacığına sahip olacağı, ancak çok sayıda olabileceği.
Böylece, programlarınızda birden fazla yürütme iş parçacığınız olur, böylece programlarınız bir iş parçacığı çalıştırır
Bununla başladığında başka bir iş parçacığı yaratır
Bir şey yapar ve daha sonra başka bir iş parçacığı pratik vb. Programın tamamı boyunca dayandıkları farklı parçaları yapabilir.
onlar
bu görev tamamlanırken yalnızca kısa bir süre devam edebilir
Programınızı nasıl yapılandırdığınızla ilgili olarak farklı şeylerden işleri alan birden fazla kişiye sahip olabilirsiniz.

Turkish: 
Önemli değil ama işletim sistemi açısından şimdi
Farklı konulara farklı konuların programlanması, sisteminizde sahip olduğunuzdan dörte biri olmasına rağmen, bunun arkasındaki fikir olmasına neden olur.
Çoklu iş parçacığı işletim sistemine, bilgisayarımda çalıştırmak istediğim farklı şeyler olduğunu söylemenin hafif bir yolu.
Bunun her zaman bir programın parçası olup olmadığı
veya birden fazla program aracılığıyla birden fazla iş parçacığı ve bunlardan hangisinin CPU çağrılarının herhangi birinde CPU zamanı alacağını seçen işletim sistemleri
sahip oldukları fiziksel veya sanal
mevcut
Şimdi, aslında ilginç bir konu ortaya çıkaran birden fazla konuya ayırdığınız bir program olmanız halinde ortaya çıktı.
Çünkü, programlarınızın artık bir program yapmalarını beklediğiniz görevi yapamayacağı bir noktaya gelebilirsiniz.
Sadece birbiri ardına çalışan tek bir talimat akışıydı ve bu yüzden ikide gerçekleştirecekleri sırayı biliyordu.
Yürütülmekte olan öğretimin çoklu yönlerine
Bazen paralel olarak bazen birbiri ardına ama artık elinizde

English: 
Doesn't matter but from the operating system point of view it's now
Scheduling different threads onto the different cause whether that's one to four however many you've got in your system so the idea behind
Multi-threading is a sort of lightweight way of saying to the operating system these are the different things I want running on my computer
Whether that's always part of one program
or multiple threads through multiple programs and the operating systems choosing which one of them actually gets CPU times on any of the CPU calls
physical or virtual that they have
available
Now that it produces if you were actually one program that you've split into multiple threads that introduces some interesting issues
Because you can get to the point where your programs can no longer do the task that you expect them to do a program which
Was just one single stream of instructions executing one after the other and so he knew the order they'd execute in two
to multiple strengths of instruction that are executing
Sometimes in parallel sometimes one after the other but you no longer have any

Turkish: 
İşletim sistemi aynı anda iki iş parçacığını yerleştirebileceği için olan siparişi kontrol edin
Veya bir iş parçacığının çalışıp sonra diğer iş parçacığını birbiri ardına takıp sonra geri döndüğünü söyleyebilirim.
Kontrol, bir anahtardan geçtiği yer
diğerine bunu laptopumda ilginç bir programla gösterebilirim
Yani burada elimde bir program yazacağım.
1 ile 1 milyon arasında tüm sayıları toplar ama bunu ikide yapacağım
Konular burada Reds ile iki tane yazdım, konu oluştururken buradaki ilk işte bu
Umarım iş parçacığı işlevi denir?
0 olarak başlatacağımız bir değişken var ve bunu geçici olarak ilan ettim.
Sadece C derlemesini söylemek için değişken ve değişecek
Çalışırken, aksi halde daha da fazla sorun yaşarsınız; ikiye böldüğünüzde, birincisi ilki toplar.
İkincisi 500,000
tamamen aynı yani ikinci anda ekliyor
500,000, yani yaptığı şey, onun katılması
500,000 ila 1 milyon ve aynı değişkene ekliyorlar, o yüzden bir tane alacağını söylesin

English: 
Control over the order that would happen because the operating system might put two of their threads on at the same time
Or I might let one thread run and then put the other thread on after the other and then go back and you can all
Control, where it's switch from one
to the other I can show this with an interesting program on my laptop
So what I've got here is I'm going to write a program that
adds up all the numbers from 1 to 1 million but I'm going to do that in two
Threads so I've written two with the Reds here creating threads the first one is this routine here
Which is called the hopefully thread function?
We've got a variable a which we're going to initialize to be 0 and I've declared this as a volatile
Variable just to tell the C compile and it will change
While it's running because otherwise you'd have even more problems so split in two so the first one is adding up the first
500,000 the second one
exactly the same so it's adding at the second
500,000 so what it's doing is it's adding up from
500,000 to 1 million and they're adding that's the same variable so go instruction he's going to fetch one

Turkish: 
Bir sonrakinin engerek ve geri yaz sonra diğeri onu alacak
Değeri ekleyin ve tekrar yazın, sonra da programımızı çalıştırıyoruz.
Her iki parçayı yarattığımızda ve onların tamamlanmasını beklediğimizde, bu ne?
Atma eklemi yapıyor ve sonra sayıyı basıyoruz
Programı yürütürken 1 ila milyon arasındaki tüm sayıları toplamayı seviyorsanız, bunu yaptık.
Öyleyse, 500 kat elde edeceğiniz sonucun 500 katı olduğunu göreceğiz, o yüzden bunu derleyelim.
Hata yapmamak problemleri derlerdi ve hadi bu programı çalıştıralım
ve bana sekiz altı altı sekiz dokuz yedi yedi dört sekiz iki iki altı sıfır cevabını veriyor
eğer tekrar çalıştırırsam
şimdi cevap üç üç üç dokuz altı üç sekiz iki altı yedi iki altı tekrar koşacağım ben
cevabı al üç iki altı sekiz yedi, oh dört oh dokuz beş Q bir tekrar çalıştırdım 307 için iki tane alacağım
501 beş 490, telefon numarası gibi geliyor

English: 
Adder on the next one and write it back and then the other one's going to fetch it
Add on the value and write it back and so on so then we then run our program
When we create both threads and then we wait for them to complete which is what this P
Throw joint is doing and then we print out the number that
We've got so if you just like to add up all the numbers between 1 and a million while I run the program
Then we'll see what result we get 500 times you'd billion so let's just compile this up
Not making mistakes the problems would compile this up and let's just run this program
and it's giving me the answer to eight six six eight nine seven four eight two two six zero
if I run it again I
now get the answer three three three nine six three eight two six seven two six I'll run it again I
get the answer three two six eight seven, oh four oh nine five Q one I run it again I get two for 307
501 five 490 which sounds like a phone number

English: 
Well this all this all converge on the right answer all leverage out or is this just one of those
completely
Well if you think about it
Should always be the same you've got you're adding up all the numbers between one and a million you should always get the same answer
It shouldn't be converging on something you should always be producing the same answer so something very very odd is going on on my computer
Something very very bizarre is going on we could write the program less in fact let's just write the program normally
let's comment out all this and we'll just write a very quick program that adds up all the values from 1
to a million so what I is less than or equal to 1
I'm sorry so it may be a single-threaded program now it's just going to run on one thread
And if we do that we compile it
We now get the same value each time
500 and whatever those so now we've done single-threaded
we're getting around certain we're getting the same answer each time so what's going on here well you need to think about what's happening in
This program, so let's just put it back to where it was

Turkish: 
Peki, bütün bunlar doğru cevap üzerinde birleşiyor tüm kaldıraç gücü veya bu sadece bunlardan biri mi
tamamen
Eğer düşünürsen
Her zaman sahip olduğunuzla aynı olmalı, bir ile bir milyon arasındaki tüm sayıları topladınız, her zaman aynı cevabı bulmalısınız
Her zaman aynı cevabı verdiğiniz birşeye yaklaşmamalı, bu yüzden bilgisayarımda çok tuhaf bir şey oluyor
Çok tuhaf bir şey oluyor, programı daha az yazabiliyoruz aslında programı normal olarak yazalım
Tüm bunları yorumlayalım ve sadece tüm değerleri toplayan çok hızlı bir program yazacağız 1
bir milyona, yani 1'den küçük ya da ona eşit olanı
Üzgünüm, bu yüzden tek iş parçacıklı bir program olabilir, şimdi sadece bir iş parçacığında çalışacak
Ve eğer bunu yaparsak derleriz
Şimdi her seferinde aynı değeri alıyoruz
500 ve bunlar ne olursa olsun şimdi tek iş parçacığı yaptık
Her seferinde aynı cevabı aldığımızdan emin oluyoruz, bu yüzden burada neler olup bittiğini iyi düşünmelisin.
Bu program, hadi sadece olduğu yere geri koyalım

English: 
if we look at this instruction here a
equals a plus I then what this was telling this program to do is to fetch the value of a
whatever that is
then add on the value of I to it and
Then store the result back in a now if I just put that to one side and find my paper
Which is over here with my pens if we? Were to write that in machine code
I'll use the arm ship to do that because it just makes things slightly easy to see what's going on
We would have this is thread 1 so we'll call this t1 we're going to say that this is going to be an LDR instruction
To load a value from memory so they're loading to be registered let's use our 0
the value of a
We're then going to add onto
Our 0
The value of r1
Which is a register containing our loop counter that's the same as I on there and then we're going to store

Turkish: 
Buradaki talimatlara bakarsak,
artı bir eşittir ben o zaman bunun bu programın yapmasını söylediği şey ...
bu her neyse
sonra ona I değerini ekleyin ve
Öyleyse, sonucu bir tarafa koyup kağıdımı bulursam, bir an önce sonucu saklayın
Hangimiz burada, tükenmez kalemimle? Bunu makine kodunda yazıyorduk
Bunu yapmak için kol gemisini kullanacağım çünkü bu sadece neler olduğunu görmek için işleri biraz kolaylaştırıyor
Bu konu 1'e sahip olacaktı, bu yüzden buna t1 diyeceğiz, bunun bir LDR talimatı olacağını söyleyeceğiz
Bellekten bir değer yüklemek ve böylece kayıt olmak için yükleyelim.
değeri
Sonra ekleyeceğiz
Bizim 0
R1'in değeri
Hangi döngü sayacımızı içeren ve oradaki benimle aynı olan bir kayıt defteri.

Turkish: 
R 0 değeri
Bir Sezar'ın 3 makine kodu talimatı haline geldiğini biliyorsunuz.
programın bir iş parçacığında yürütme şekli, değeri bellekten yüklüyor ve
Yerel bir kopyasını çıkartıyor ve sonra ona değer katıyor
yerel kopyasını günceller ve geri saklar
asıl konuma ve bu iplik onu ilmek içine çekmeye devam eder, böylece onu yükler.
Üzerine bir şey vardı ve geri yüklediğinde ona başka bir şey ekledi
Çok iş parçacıklı bir sistemimiz varsa şimdi depolayın, bizde ne vardı?
ayrıca başka bir Steve var Steve Merhaba Steve ve
bu durumda
Burada olacağım
değeri yüklüyor bence değeri üzerine geri depolamak
Ve ben buraya bir şey ekleyerek bir değer yükleyip geri yükleyeceğim, böylece değer yüklüyorum
ona bir şey ekleyerek değer yüklüyorum
ona bir şey ekleyerek değer yüklemek
üzerine bir şeyler ekleyerek geri depolamak

English: 
the value of R 0
Back you know so that one Caesars have become 3 machine code instructions
so the way that the program is executing in one thread is it's loading the value from memory and
It's making a local copy of it and then it adds a value onto it
updates its local copy and stores it back
into the actual location and that thread keeps doing that into the loop so it loads it I
Had something onto it and stores it back loads it add something else to it
Stores it back now if we've got a multi-threaded system, which is what we had there, we?
also have another Steve hi Steve hi Steve and
in that case
I'm going to be here
loading the value I think value onto it storing it back
And I'm gonna be here loading a value adding something onto it and storing it back so I'm loading value
adding something on to it I'm loading value
loading a value  adding something on to it
adding something on to it storing it back  storing it back

English: 
and what's just happened Because other Steve had added something else on to it, while I'd load it on when I storm my back his update
doesn't get changed gets lost
Well that wasn't nice
So if we look at what's happening on the papal it's loading the value in it's adding the value onto it and then it's doing
It back but of course, we've got multiple systems and so at some point
this pro
Was going to start excusing the same code so let's cross this instruction out for now we'll put it back in a bit later on
And assume that at this point we load the value into the other thread
into our zero in
there
And then we do the add on in the same way
Dot and then we do the store back here
of our zero into a and we've got one a
Up here there an Singh and then this store actually happens after this store here
So what happens here is that these both end up getting the same value of a

Turkish: 
ve az önce ne oldu Çünkü diğer Steve ona başka bir şey daha eklemişti, ben de güncellemesini bastırdığımda yüklerken
değişmez kaybolur
Peki bu hoş değildi
Yani eğer papalıkta neler olup bittiğine bakarsak, değeri yüklüyor, ona değer katıyor ve sonra yapıyor
Geri döndü ama elbette, birden fazla sistemimiz var ve bir noktada
bu profesyonel
Aynı kodu çıkarmaya başlayacağız, bu yüzden bu talimatı geçelim şimdi biraz sonra tekrar koyacağız
Ve bu noktada değeri diğer dişe yüklediğimizi varsayın
bizim sıfıra
Orada
Ve sonra da aynı şekilde ekleriz
Dot ve sonra mağazaya geri dönelim.
sıfıra bir a ve biz bir tane var
Burada bir Singh var ve bu dükkan aslında bu dükkandan sonra oluyor.
Öyleyse burada olanlar, ikisinin de aynı değeri elde etmeleridir.

Turkish: 
Ve bunun yerel sicilindeki değeri var, bu yerel sicilindeki değerini atar, geri yükler
Sonra bu geri ve tabii ki saklar çünkü bu sadece burada bir hikaye
Burada depolanan değerin üzerine yazılır, böylece buraya eklenen değer
kaybolur o yüzden yapmamız gereken bir yol bulmaktır
bu iki şeyi senkronize edin, böylece değer yüklenir yüklenmez
Ve üzerine durduğu bir şey ekleyecek.
Bunu yapmaktan ve bunun bir kaç yolu var, bunu yapabiliriz
En kolay yol, bir şeye sahip olmamızdır.
her ikisi de hem Steve'in hem de CPU'ların her ikisine de erişmek zorunda ve bu yüzden bir diske sahip olalım. Disketi kullanalım Microsoft Office Professional
1995 ve söyleyeceğimiz şey ise, yalnızca bir güncelleme değişkenine erişebildiğim.
Jetonum var, geri dönelim
Dost canlısı Steve, artık bir jetonumuz var, değil mi?
Söyleyeceğimiz şey, belirteç almadığım sürece, bir değişkene erişemiyorum ve bu üçü de uygulayacağım.

English: 
And this has its value on in its local register this adds its value one in its local register this stores it back
Then this stores it back and of course because this is just story back here
It's overwritten the value that was stored there so the value that was added on here
gets lost so what we need to do is find a way to
synchronize these two things so that as soon as this is loaded the value in
And it's going to add something on to it it stops
This one from doing it and so there's a couple of ways, we can do that
The easiest way is that we have something that
both divide both Steve's or both CPUs have to access and so we could have a token let's use a floppy disk Microsoft Office Professional
1995 and what we're going to say is that I can only access an update variable a if
I have the token so let's bring back
Friendly Steve so we've now got a token and we?
What we're going to say is it unless I've got the token I cannot access a variable a so I'm going to execute those three

Turkish: 
Talimatları ne zaman alırsam belirteyim, bu yüzden bir miktar akan kazanacağım.
üstüne bir şey ekle ve sakla ve
belirteci Steve'e vereceğim şimdi belirteç var, böylece bir değer yükleyebilirim
onunla birleştirdiğim değeri ekle ve
geri sakla ve hedefi ver ve şimdi tekrar kartımı aldım.
Kayıt defterime ekle, üstüne bir şey ekle
Geri al ve belirteci al ve aldım, böylece değeri ekleyeceğim değeri bir kayıt defterinden ekleyebilirim
Geri hikaye ve belirteci geçmek
Ve tekrar belirteç aldığım için aynısını tekrar yapabilirim, ancak yalnızca birimiz belirteci herhangi bir yerde tutabilir
bir zamanlar sadece bir güncellendiği anlamına geliyor
Jetonu aldığımızda ve bu hakkı asla kaybetmeyeceğimiz için çünkü jetonu almadığınız sürece
Buna erişemezsiniz, bu yüzden dizüstü bilgisayara dönersek görebiliyoruz.
Bunu nasıl uygulayabiliriz, programımızda aynı fikri kullanacağız, daha önce sahip olmamız gereken bir şeye sahip olacağız.
Bu durumda bu kodu çalıştırabiliriz. Muteks denilen şeye sahip olacağız ve bir alanın karşılıklı hariç tutulmasını susturacağız.
kilitlememiz gerek
Çalıştırmadan önce, kodun arkasındaki kod ve sonra
bitirdik, kilidini açtık ve öyleyse

English: 
Instructions whenever I've got the token so I'll get a load of runny win
add something onto it and store it back and
gonna hand the token to Steve now I've got the token so I can load a value in
add the value from I've merged her into it and
store it back and hand the target and now I've got the token again I can load something into
It into my register add something onto it
Back and pass the token on and I've got it so I can load the value in add the value from a register
Story back and pass the token on
And because I've got the token again I can do the same again but because only one of us can hold the token at any
one time it means that only a can get updated
When we've got the token and so we never lose that right because we're saying that unless you've got the token
You can't access that very that's great so if we turn back to the laptop we can see
How we can implement that in our program we're gonna use the same idea, we're gonna have something that we need to have before
We can run that code in this case we're going to have what's called a mutex and mute an area mutual exclusion
that we need to lock
Before we can run, the code after it and then when
we finished we unlock that and so if it's

English: 
Locked and we try and acquire it our program will pause until it is able to lock it
So I'm going to do is I've created the variable for it here and I've
Also initialized it down here so it's all set up
Ready to go so before I add onto a that the value of the instructions I'm going to lock that
mutex
like so and then afterwards
if I could type I'm going to unlock that mutex
Like so and I need to do the same in the other thread as well so I'm going to lock the mutex
I'm going to unlock it afterwards
So if I can pile this version up
we still got two threads we're still getting them to add up the things as we go through it and then at the end
We're going to add the result and it should this time give us the right answer

Turkish: 
Kilitli ve biz onu almaya çalışacağız ve programımız kilitleyene kadar duraklayacak
Yani yapacağım değişkeni burada yarattım ve
Ayrıca burada başlattı, böylece her şey ayarlandı
Buna eklemeye başlamadan önce hazırım talimatların değeri onu kilitleyeceğim
muteks
bunun gibi ve sonra
eğer yazabilirsem, bu muteksin kilidini açacağım
Bunun gibi ve aynı şeyi diğer iş parçacığında da yapmam gerekiyor, bu yüzden muteksi kilitleyeceğim
Sonra kilidini açacağım
Öyleyse bu sürümü bir araya getirebilirsem
Hala iki ipliğimiz var, hala ilerledikçe ve sonunda da şeyler eklemeye devam ediyoruz.
Sonucu ekleyeceğiz ve bu sefer bize doğru cevabı vermeli

Turkish: 
hadi koşalım ve
Bize sorunu şimdi iki CPU'da çalıştıracağımıza bölüyoruz ve bu değişkeni kilitlediğimiz için doğru cevabı veriyor.
Sadece bir iş parçacığı ya da diğeri tarafından erişebiliriz
Yani, iki Steve ile yaptık, o zaman doğru sonucu alabiliriz ve her seferinde aynı sonucu verir.
Şimdi bunun dezavantajı, her seferinde ipliğin kilitlenmesinin programın çalışmasını yavaşlatmasıdır.
Ancak, eğer altı sayı eklersek, toplama hakkında düşünürsek akıllı olabiliriz.
Bu ekleme ile aynı
Birlikte üç sayı sonra üç sayıyı bir araya getirmek ve her ikisinin de sonuçlarını elde etmek ve burada aynı şeyi yapabiliriz
yani, bu muteksiyi alabiliriz ve
Ana döngünüzün dışına ve her seferinde I değerine yuvarlamak yerine onu taşıyın
yerel bir değişkene sahibiz, buna yerel olarak adlandıracağız, buna her şeyi ekleyeceğiz, bu yüzden yerel bir yerel
artı ben

English: 
so let's run it and
It gives us the right answer we now split the problem into it's running on two CPUs and because we're locking that variable so
We can only access it by one thread or the other
So, we did with the two Steve's then we can get the right result and it produces the same result every time
now the downside to this is that locking the thread each time slows the running of the program down
But we can be clever if we think about addition if we add six numbers together
That's the same as adding
Three numbers together then adding three numbers together and having the results of both together and we can do the same thing here
so, we can take this mutex and
Move it outside of our main loop and instead of rounding on the value of I each time
we have a local variable we'll call it local a which we add everything on to so we say local a equals local a
plus I

Turkish: 
Yani iş parçacığımızın içinde sadece daha önce yaptığımız gibi tüm değerleri eklemeye gidiyoruz, çünkü işe yaramadı
Bu iş parçacığına ve bu işleve yerel olan yerel değişken
Sorun olmayacak çünkü sadece bu fonksiyon ona erişebiliyor, diğer iş parçacığında da aynı şeyi yapıp
Dışında da aynı şey ve bunu yapmanın avantajı şu anda sadece bu kilidi almak zorunda olduğumuz.
Her iş parçacığında bir kez, her bir ekleme için onu almak zorunda kalmak yerine, programa zaman ayırırsak bir kez almak zorunda olup olmadığınızı
Önceden ve şunu söylemeliyim ki, program o kadar hızlı çalışıyor olabilir ki, doğru bir zamanda daha iyi bir zaman elde edemeyiz.
Yine de denemezdim, o zaman gelen zamanı kullanın.
Sekiz iki saniyenin dokuz puan aldığını görüyoruz, hadi tekrar çalıştıralım ya da yedi noktaya geçelim
Yedi noktadan biri de
Naemp point 7 ile ilgili bu tür şeyleri standart hale getirmiş gibiyiz. Şimdi hızlı versiyonumuzu şimdi derleyelim.
Herhangi bir hata yapılmadı ve tekrar zamanlayacağız, bakalım doğru değeri de üretecek.
Ve aynı saatte sürüyor

English: 
So inside our thread we're just going around adding all the values on as we did before which didn't work because we're putting in a
Local variable that's local to that thread and this function
It's not gonna be a problem because only this function can access it well do the same in the other thread and then we'll do
The same thing outside it and the advantage of doing this is that we now only have to acquire that lock
Once in each thread rather having to acquire it for every single addition, whether you have to acquire it once if we time the program
Beforehand and I should say at this point the program may be running so fast that we won't better get an accurate time and it
Wouldn't try anyway so use the time coming to time it
We see it takes about nine point eight two seconds let's just run it again nor point seven one
Nor point seven one
We seem to have standardized around that sort of things about naught point seven so let's compile up our faster version now
Not made any mistakes and we'll time it again, well let's see produces the right value will time it as well
And it's taking around the same time

Turkish: 
Biraz düşüyor ve zaman içerisinde herhangi bir fark yaratmıyor bence bilgisayarların ne kadar hızlı olduğu
Bununla uğraşıyoruz ama daha büyük bir programla daha fazla hesaplama yapıyoruz
Çok fazla ihtiyacımız olan süreyi azaltmak, sistemi gerçekten çalıştırır.
Daha hızlı ve çok iş parçacıklı olması, programımızı farklı zamanlar boyunca çalışan birden fazla çalıştırma dizisine bölme fikridir
İşleri doğru sırada yaptığımıza dikkat etmeliyiz ve
aynı değişkene aynı anda erişen birden fazla iş parçacığı
Özellikle eğer ondan okuyorlarsa yazıyorlarsa, birinin yazıp yazmaması ve ondan bir kaçının okuması önemli değil
Önemli olsun belki de bir olsun. Bir seferde eski değer sonra iyi çalışıyor vb
Aynı
A1 mesajın şifresini çözebilir ve doğru okuyabilir, böylece Alice başka bir tane daha göndermek isteyebilir, böylece işaretleyecektir
Bu KDF işlevi tekrar yeni bir anahtar ve a2 üretecek
bunu Bob'a gönderecek, bu alma işlevini alacak. a2
Şimdi Bob bir mesaj göndermek istiyor, o da kene çalacak

English: 
It's dropping a bit and it doesn't really make any difference in time I think that's just because of how fast the computers are
That we're dealing with but with a bigger program we're doing more calculations
Reducing the number of times we require that a lot would actually make the system run
Faster so multi-threading is the idea breaking our program up into multiple threads of execution that run for different lengths of time but
We have to be careful that we do things in the right order and we avoid having
multiple threads accessing the same variable at the same time
Particularly if they're writing if they're just reading from it it doesn't matter if one's writing and several the reading from it and it doesn't
matter if they perhaps get an. Older value at a time then it works fine and so on
That same
A1 so that he can decrypt the message and read it right so Alice maybe wants to send another one so she's going to tick
This KDF function again she's going to produce a new key and a2
she's going to send that to Bob he's going to take this receiving function a2
Now Bob wants to send a message so he's going to tick
