Scala Futures

Noen ganger, mens vi utfører komplekse beregninger, forventer vi at programmene våre utfører forskjellige oppgaver samtidig for å ha bedre hastighet og effektivitet. Dette konseptet spiller en viktig rolle, spesielt når vi ikke vil at de tidkrevende oppgavene skal blokkere hele behandlingen vår. På Scala -programmeringsspråket kan funksjonaliteten til tråder oppnås ved å bruke Scala Futures, og vi vil lære mer om dem i denne artikkelen.

Hva er Scala Futures og hva er formålet med å bruke dem?

Vi har uttalt i innledningen at Scala Futures tjener samme formål som tråder på noe annet programmeringsspråk i.e., Samtidig. Det betyr at ved å lage en scala -fremtid for enhver oppgave som forventes å ta lengre tid enn vanlig å utføre, kan du utføre andre oppgaver parallelt. Dette vil spare beregningstiden din uten å blokkere den normale strømmen av programmet ditt.

Eksempler på å bruke Scala Futures

Hvis du ønsker å bruke Scala Futures i Ubuntu 20.04, da vil følgende to eksempler hjelpe deg med å gjøre det.

Eksempel 1: Komme i gang med Scala Futures

I dette eksemplet ønsker vi bare å dele med deg den generelle syntaksen ved å bruke Scala Futures. For å lære det, må du ta en titt på Scala -koden vist nedenfor:

For å bruke Scala Futures, må du først importere de to nødvendige bibliotekene i.e., “Scala.samtidig._ ”Og“ Scala.samtidig.ExecutionContext.Implikasjoner.global". Etter å ha importert disse bibliotekene, er det neste du trenger å gjøre å lage en kjørbar klasse. Vi har opprettet en klasse som heter "Test" ved hjelp av "Objekt" nøkkelord. Deretter, innen denne kjørbare klassen, har vi laget en driverfunksjon “main ()” inne som vi har laget en verdi som heter “fut”. Deretter har vi tildelt den en scala -fremtid. Inne i denne fremtiden ønsket vi å utføre to forskjellige oppgaver.

På grunn av den første oppgaven legger vi i utgangspunktet programmet vårt i dvale i 1 sekund. Deretter ønsket vi å beregne resultatet av uttalelsen “21 + 21”. Imidlertid vil vi oppgi her over at denne andre oppgaven bare vil bli utført etter at den første uttalelsen vil fullføre utførelsen. Deretter ønsket vi å skrive ut resultatet av "fut" -variabelen. Dette resultatet vil returnere "ikke fullført" hvis utførelsen av ovennevnte fremtid fortsatt vil være i påvente; Ellers blir resultatet av den andre uttalelsen beregnet. Derfor blir begge oppgavene fullført. Til slutt ønsket vi å skrive ut en melding på terminalen som vil varsle brukeren om at utførelsen av denne funksjonen er delvis fullført.

Vi vil kunne kjøre dette Scala -skriptet bare når det er samlet, noe som kan gjøres med følgende kommando:

$ Scalac Futures.Scala

Når dette Scala -skriptet blir samlet godt, kan vi kjøre det med kommandoen vist nedenfor:

$ Scala Test

Utgangen produsert av dette Scala -skriptet vises i følgende bilde. Det avbildet bruken av Scala Futures i Ubuntu 20.04.

Eksempel nr. 2: Utføre to uavhengige oppgaver- en med Scala Futures og en annen normalt

Nå vil vi ta et skritt videre ved å forklare deg et praktisk eksempel på å bruke Scala Futures i Ubuntu 20.04. I dette eksemplet vil vi utføre to forskjellige oppgaver. Den første vil bli oppnådd ved hjelp av Scala Futures, mens den andre blir henrettet normalt. Vi har med vilje designet den første oppgaven på en måte som utførelsen vil ta litt tid. Nettopp derfor har vi omsluttet denne oppgaven innen scala -fremtiden. Imidlertid, for den andre oppgaven, er den designet på en måte som den blir utført raskt. På denne måten vil vi motta utdataene fra den andre oppgaven før vi mottar utdataene fra den første oppgaven. For å forstå denne funksjonaliteten, må du sjekke ut Scala -skriptet nedenfor:

Igjen, i dette Scala -skriptet, har vi først importert de to nødvendige bibliotekene. Deretter har vi opprettet førerklassen og førerfunksjonen på samme måte som vi har gjort i eksemplet ovenfor. Etter det har vi laget en verdi som heter “FUT”. Til dette har vi tildelt Scala -fremtiden vi har brukt en tråd som vil kalle "søvn" -funksjonen et sekund. Deretter opprettet vi en verdi som heter “X” og har tildelt den resultatet av uttalelsen “2+2”. Etter det ønsket vi å skrive ut denne verdien på terminalen og deretter skrive ut en melding om at den andre oppgaven jeg.e., Beregningen av “X” er fullført med hell. Deretter ønsket vi å skrive ut verdien av "FUT" -variabelen som vil avhenge av utførelsen av vår Scala Future. Til slutt ønsket vi å skrive ut en melding på terminalen for å varsle brukeren om at den første oppgaven nå også er fullført.

Etter samlingen og utførelsen av dette Scala -skriptet, dukket det opp følgende utgang på terminalen. I denne utgangen, først, resultatet av vår andre oppgave jeg.e., 2+2 ble skrevet ut på terminalen som er “4”. Deretter ble vi varslet om at den andre oppgaven har blitt utført med hell. Etter det ble resultatet av vår "fremtid" skrevet ut på terminalen etterfulgt av en annen suksessmelding.

Konklusjon

Vi ønsket å introdusere deg for konseptet Scala Futures i Ubuntu 20.04 Ved hjelp av denne guiden. Først delte vi med deg hva Scala Futures er, og hvordan forholder de seg til begrepet tråder og samtidighet. Etter det etablerte vi en sunn forståelse av Scala Futures ved å oppgi formålet med å bruke dem. Deretter implementerte vi to veldig grunnleggende eksempler som benyttet seg av dette viktige konseptet i Scala -programmeringsspråket for å oppnå samtidighet. Ved hjelp av denne guiden og disse eksemplene kan du implementere mer komplekse eksempler der du vil kunne utføre flere oppgaver samtidig ved hjelp av Scala Futures.