[Powered by Google Translate] Nate Hardison: Quan tens diversos programes oberts en un
ordinador, sembla que tot està
executant a la vegada.
Per exemple, vostè podria estar treballant en un navegador web com
Firefox o Internet Explorer, escoltar música a iTunes,
i escriure un assaig amb Word.
No obstant això, sota el capó, els programes de realitat
executar un alhora.
És el treball del sistema operatiu, Windows, Mac OSX, o
Linux, per gestionar cada un d'aquests processos independents, com la
programes es coneixen, i canviar entre ells perquè quan
van des del control de la seva pàgina de Facebook per treballar en el seu assaig
de nou, la Paraula és la que s'està executant.
>> De vegades, però, volem propis programes per poder
per fer diverses coses com aquesta, també.
Si ets com jo, probablement tens un munt de
obrir diferents pestanyes en el navegador web, una per correu electrònic,
un amb un calendari, i així successivament.
Podríem tractar cada pestanya com un programa independent o procés,
com Google Chrome ho fa, però molts programes usen un
més lleuger de pes versió d'un procés anomenat un fil.
>> Un fil és simplement una altra unitat de processament, un conjunt de
instruccions o codi que pot "córrer", entre cometes,
al mateix temps que altres subprocessos.
Això és el que fa que sigui possible per tu per navegar per Facebook
mentre escolta a mi en el fons, o amb dos
Els vídeos de YouTube jugar a la vegada.
Per tant, aquest tema general, conegut com la concurrència, en general
no ve tan d'hora en els cursos de ciències de la computació
perquè els detalls de nivell inferior requereixen discussió de
sistemes operatius i similars.
No obstant això, el llenguatge de programació que utilitzem en la
a partir de CS50, Scratch, proporciona algunes eines enginyoses per
que sigui més fàcil escriure programes amb múltiples coses
succeint al mateix temps.
>> Quan es genera programes Scratch, vostè està constantment
treballar amb fils.
Cada seqüència de zero, que és un bloc de codi que comença amb
una de les peces del trencaclosques "quan", es pot considerar
com un subprocés independent.
Fem una ullada a un programa simple rascada per veure com funciona això.
>> Aquí, tenim un objecte de peix o sprite, amb dos guions
que tots dos comencen quan fem clic al botó petit bandera verda.
El primer script controla el moviment dels peixos.
Quan la bandera verda es fa clic, el peix es col · loca
a la banda esquerra de la pantalla, anomenada l'etapa,
enfront de la dreta.
Després, en un conjunt d'instruccions que s'executen trobar sempre, fins que
aturar el programa, el peix es llisca cap al costat dret,
es gira, es remunta a l'esquerra, i
es gira de nou.
El segon script controla el procés del peix pensament.
Resulta que aquest és un peix famolenc.
Així que després d'esperar durant 3 segons, el peix pensarà,
"Tinc fam", durant un segon quart.
Aquest script també s'executa sempre.
I com veiem, en executar el programa fent clic al
bandera verda, apareixen dos guions per executar
simultàniament.
El peix es mou i pensa alhora.
>> Atès que el pobre peix es veu tanta gana, anem a afegir en alguns
glopades de formatge per menjar.
És d'esperar que no es desintegri en l'aigua.
Quan afegim un sprite en segon lloc, també serà capaç de
afegir en els scripts corresponents a aquest sprite.
I, per tant, no hi haurà un altre conjunt de
temes que executarà.
Per donar a l'usuari el control del nostre programa acaba quan el
peix famolenc aconsegueix menjar, diguem que cada vegada que l'espai
Bar és copejat, puffs cursi aparèixer a l'escenari per a la
peix per menjar.
Abans de colpejar la barra d'espai, es voldrà mantenir el formatge
puffs oculta perquè els peixos no poden veure'ls.
Per això, anem a necessitar un parell de guions per a la
puffs cursi Sprite.
El primer guió, la bandera verda, s'acaba d'amagar el menjar.
A diferència de les altres escriptures que hem escrit, aquest no es mantingui
funcionant sempre.
Es començarà i acabarà molt aviat, just quan fem clic
el botó de bandera verda.
>> L'script següent que hem d'esperar a que la barra d'espai per ser
pressionat abans de l'execució.
Podem cridar a l'espera de l'entrada de l'usuari "a l'espera" o "escoltar"
per a un esdeveniment.
I el codi que s'executa quan es rep un esdeveniment o
sentit s'anomena codi de control d'esdeveniments.
La nostra barra espaiadora controlador d'esdeveniments mostrarà les glopades de formatge
la pantalla perquè els peixos es poden menjar.
En aquest punt, tot es veu bé.
>> El següent que hem de fer és trobar la manera d'obtenir
els peixos per adonar-se que cal menjar.
Anem a afegir un altre fil per als peixos que constantment
comprova si és o no és tocar les glopades cursi.
Fem això en un fil separat ja que el que puguem
comprovar constantment pel menjar.
En cas contrari, només seria capaç de comprovar periòdicament si hi ha menjar
entre delta, donant la volta, esperant, o pensant.
>> Acceptar.
Ara anem a executar el nostre programa Scratch.
No és sorprenent, el menjar immediatament amaga i la
peixos famolencs llisca cap endavant i cap enrere com abans.
Quan es prem la barra espaiadora, les glopades cursi sortir a la llum,
i el peix famolenc diu Whoo.
Però espera, això és estrany.
Com és que el peix "Tinc fam" interromp el pensament
altres coses?
Això és perquè no va establir cap tipus de coordinació
entre els tres guions de peix.
Cadascun s'està executant en el seu propi fil, aliè al que el
altres estan fent.
Anem a arreglar això abans de seguir endavant.
>> La coordinació entre els fils és una tasca difícil ja que
no tenen control explícit sobre quan s'executa cada fil o
no s'executa.
Per enviar un missatge d'un fil a un altre, haurem de
utilitzar una variable que es pot configurar, ni escriure, en un fil
i llegir en l'altre.
Crearem una variable anomenada foodFound que podem posar a
cert quan el peix es troba amb les glopades de formatge.
Bé, és clar, volem assegurar-nos que el que estableix
false inicialment.
Després, en el pensament fil del peix, anem a comprovar si
el peix ha trobat menjar abans de mostrar el "tinc gana"
pensament bombolla.
>> Ara, en executar el programa de nou, es veu que el peix
no s'interromp amb pensaments de fam quan el
formatge puffs estan fora.
L'últim problema que tenim és que les glopades cursi no van
desapareix després dels peixos, citar fi de la cita, "es menja" d'ells.
A partir de les seqüències d'ordres de peix, no hi ha manera fàcil d'ocultar el formatge
puffs, així que hem d'enviar un missatge als bufs amb formatge
sprite per ocultar.
Podem fer això amb una altra variable que les glopades cursi
sprite té accés a, així com el sprite peix.
>> No obstant això, hi ha una forma més neta de fer això en aquest cas,
ja que en lloc d'enviar un missatge a un guió que és
en algun lloc en el medi d'execució, es pot enviar la
missatge a un guió que està esperant per començar.
Fem això fent que el peix retransmetre un esdeveniment, que tractarem
trucar menjat.
A continuació, crearem una escriptura per les glopades cursi que la voluntat
esperar per aquest esdeveniment.
Això és similar al cas de la barra espaiadora, excepte que aquesta
temps, l'usuari no és el que directament activa l'esdeveniment.
Ara tot el que hem de fer és configurar l'esquena variable de foodFound
en false, i ara podem donar als peixos famolencs com molts
porcions de formatge puffs com vulgui.
>> Així que no és tan dolent, oi?
En C, escriure programes multifil és més complicat,
però els fonaments són els mateixos.
De tota manera, espero que tinguis un bon moment la construcció d'una bona estona
programes concurrents en Scratch.
El meu nom és Nate Hardison.
Això és CS50.