Merken

Inside ActiveJob

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
thanks I thank Ozan standards that itself is this is uh inside actor John this is the beyond the magic track of my name is Jerry D. Antonio on get started so 1st a tiny bit about me and I live and work in Akron Ohio if you're an NBA fan you probably for tobacco and there's a local kid of is a basel players and prewar from 7 NBA I went to school about that time is relative and test double on neighborhood of test I just answers are among the founders of was on the Program Committee for those copies of on the speaking tomorrow I'm test of our mission is to improve the world both software and unnecessary audacious but we truly believe that every programmer has it in themselves to do that I believe the person here has themselves to do that that's why you're here so I'm by definition they could be work for and very proud represent a stub here and didn't personally I 1 thing I've done it is then defined like they created a ruby gem called on concurrent will be you may have heard of concurrent Ruby because it's sort abuse and some of the well-known projects like for example wells that Caribbean is a dependency of action cable in rails for 5 it's parties by sprockets used by some gems like SideKick sucker punched used and bioactive certain letter certain alive static Tony's company a Microsoft is you're Ruby tools so but much of what I'm going to talk about today draws a severe Internet and but this is not to be a sales pitch for that this is be about active job in rails itself and so because this is a the beyond magic track and this is not a very introductory con on top topic this is gonna be patterns rather this is going to be a deep dive into the internals of active job so had to make a couple of some assumptions in doing this I'm basically assuming that if you're here used active job problem production you've used 1 of the he supported job processes you have some understanding of concurrency and parallelism on if you need a better introduction to active job itself I highly recommend the rails guides thrills guys a break excellent at this and write a lot of great information on the introduction into concurrency within Ruby itself and the same was applied as I did give a presentation last fall at become called everything you know about the GAO is wrong but at Roseville 1 to and that'd be a reduction in that so with that let's jump into what is active jobs right
so I need to briefly in order to get into the internals of this I needed briefly remind us of what it is and we're coming from so your active job according to rails guides definitions this at jobs a framework for declaring jobs making them on a variety of queueing backends just be everything from regulates Vejle cleanups to billing charges mailings anything that can be chopped up in small units of work run in parallel OK a couple key terms it's a framework right we'll talk more about this but asynchronous job processing pre-existed active job OK there were there were things like I corrected and are that the effect of the delay job queue Q rescue sidekick sneaker ca . many of these things existed Before Active job was created an active job came along as a way of unifying those like and active job helps us schedule tasks to be run later that was mentioned briefly this morning in the keynote that when you don't want to block the currently running of bread requesting want something happened later you use active job and make that happen that allow and do occur asap are setting which is aware of the fit to this as soon as you can or by steadily at a later date and time potentially text and this is also the losses to support full parallelism and that's why some of the job processes are multi-threaded many of them however actually 4 four of about working well and can run in multiple processors on a Chinese is scale across and mental processes in some cases across multiple shots and model so the the distractor job is that the background job processes exist to solve a problem that we have these long-running tasks sense that we don't want to block the web requests so remember the % a response back to power of the user and get the page rendered for them and some these tasks that occurred after that so for example from sending e-mail you know takes time station to begin with why should I block the red request to make sure that you know post when I can send the response that had that poster really after yeah so so active job so that in the processes behind that support that high cycle said in acted jobs and important in the internals of actor John came later and there all of the job processes each 1 as you might want to know how do virtually the same thing it's different capabilities of differently also have the same problem right so that only job was created to provide a common abstraction layer over those processes that allow the rails developer to not worry about the specific implementation the widest sense no this is not dissimilar to what Active Record does by relational databases existed Active Record create abstraction layer over that that allows us to run we use different databases the tougher the fruits with between different databases is necessary most importantly among different databases and test product right active job does the same thing allows substructure the allow us to choose different processes change different processes as the needs occurred and 1 with 4 processors in test development and production of the end and so that a job how to do that while supporting the existing tools that people are already using so closed as is speaking at showing back and becomes more of an operational concern user developer don't care which back in is being used you simply devote your jobs and let the after the mutagenic back in whatever environment makes the most sense so because of its 1 real briefly remind us what the code looks like for active job before jumping internal so that was a simple job classes to look familiar body the important things are that this class extends the active job base and that it has a method called perform right most of what active job doesn't castle only in the active job class which goes in and will eventually as you look through the details call this perform method on you or an object of this class when the job actually runs and with is the right and as a reminder of where we can feel back and to use this job queue effective job queue adaptive configuration options within our application Bobby Knight inside jobs when the call the adapter Robin built here to actually build in here that's in real adapter that its function at the price so that the graph of the adapters that are supported by rail have a i as a symbol that follows a normal Windows inflections that maps the adapter name to what he said the right for so if inside job existed as a supported adapter in red visibly higher Woodward said that right then that's a key figure which back and you want use username and you actually do something later you call the perform later method on your class passing it 1 or more parameters that should merely on and if you want to schedule a job for a certain time then you can use the set function to specify when there's a number of different ways you can do that so that's a reminder of what we see in front of active job on the back to the Committee everybody we talk about is what goes on behind that when you make this performed later called the so that is a member of a the basic is back in here
red appear during this presentation 1 actually works in its functional and will only it's minimal but will meet the requirements of of active job and shows how this works so couple things just to get a sense were coming from and I can mention the are multithreaded doctors in there are 4 product multithreaded adapters run your job in the same process as real as at such as the property that the advantage of that is those can be very fast and you don't have to sponsor the processes many separate processes right on the material that MRI Ruby does have some constraints with concerns Euconst concurrency but it's not as bad as most people think that's why i talked about it roles come last fall on instance most movement is very good at multithreaded operations when you're doing blocking IO and most of the task will be because background jobs for on-demand blocking IO the send e-mail server posting things to some of other API so since they tend to do blocking I attended work very well with rooms concurrency model so they surrendered back and I'm a simpler to have the minutes of a process on minimum however due to use of the response of the flux of the processes we have non separable processes those the full parallelism but they require active management those processes so formal but here we're just you do a multithreaded 1 because I can do that that easily and demonstrate all things were going to come to reduce thread calls for that but most job process will also pursue the job data into some sort of data stored of on medicines Republic that's the reason for doing that is that if you're process and it's either on purpose or by crashing the if you all of your job is in memory uses the stuff never run generally speaking for a production you want to have a job processing and data storage of data in some sort of actual data so as to allow to persist beyond restarts when I do that here move because in simplicity I wanted demonstrate provide an active job we don't have to go to that level of effort so our job processor will not persist a to makes good for testing development time but but not necessarily 1 that we use when the bell here today for production and so it'd do this is when have 3 pieces of the first one is active job for this provided by the job itself and it is the job of metadata when talk about this more but it is the thing that defines the job that you need a form where a lot is probably the most important piece of all this because it's the glue that binds us together the choosing regretted cued up in a job like they remember active job came about after the job runners to the job under is independent and it provides the asynchronous behavior my the job on actually exist as a separate thing sidekick is a separate they sucker punch as a separate thing install although separately of the q adapter has the with its own responsibilities to marshal the job data into the simplest of processes that job clusters as a provides English behavior and the adaptive no-shows between Rails at in that job processes and those are the 2 people of build here today queued up and job run for all of the job runners supported by Wales accu adaptive is actually in the reels codebase and during student I have to get have been lost cooperation with an active job but you'll see that the a of the of q adapters and monkey adapted in there for each of the the the the the processes that that will support there's also said unit tests as part of the reals codebase the 1 against every 1 of these jump processes on every commit and then sure that all the supported job processes meet the minimum requirements of an active job and 1 million people today actually will pass that test suite and 1 that is uh so strictly speaking the readers has responsibility for the q adapters and for that that test suite I brought my experience the people who created the the job owners themselves with closely with real so make sure that on those adapted or up-to-date worked well with the process so let's stop and talk about the active job that local aspects of this is the glue that ties
altogether not right now so this is this is the job metadata is an object that represents all of the information about the job you post that but but it carries with it the properties to be running loose with things like working the problems of and then it shows that all that metadata but had the advised him very important not just talk more in this utilized Endesa eyes methods it is a very critical and or target and the German itself there are several attributes on this object which we will look at a used internally with an active job we should not be used with developer have to know about these are things that winter inside active job or very or 1 of the most humane ultimately familiar with that you can specify when you create a person is jobs but huge money against right and if you don't specifies the default view of priority was some job process support polarization were higher quality jobs 1 version not a superposition hours that's optional under the primary detectors as well we use schedule a job for a specific time you notice that letters telling when we will look at that because we are interested in just to part of the job ID is internal to Wales in is a unique ID within the wheels instance itself the think if I ICT job realize uses that would be an active job to track each 1 of the these things you provided job by doing this that is 1 that you can provide with the you a job processes so that if you wanted to the merger process we want have our own kind of ID system that makes sense for us and where we could then attach it to the job metadata and under the prior job ID OK so resources not create that we create ourselves we're not user-provided job ID today is not essential but it is available at something we would ask right so that's actually build ECU adaptable outside it right so these are the kid adapters responsible for motion data into the job processes the jump processes the more interesting pieces look at that and minute underwear start with the q that was sort of good sumo TDD that's right the kid that most of Q adapters were written when an active job was created because the jump processes already existed and they had had let Marshall and I case because we don't have a Q adapter are so you have a processor yet we can decide what the API as look like so within the queue adapted we only need to that it's very simple 1 is in Q there is in human at the inn to extend job object look at him emotions that into our process and the MQS job any time timestamp and motion second-order processes so notice in this case I decided to make the people very simple request encode inside job would have class methods and Q and and Q. at when the course with a pastiche serialized job Repast accumulating in the case of the injury has a timestamp so because there's no but 1 this is not very o uses class-level methods that we're calling on this class and I did that because I want to emphasize the stateless nature of this this is very critical to understand an active job is by its nature state was the state for your job is encapsulated in that job object that all of the metadata about the job everything later that up all of your state is anathema passing through the actual adapt itself is inherently state was weird its job is just to that in your in your notes call a classical method when pose the job because we're sending this thing to happen later on it's a fire forget would not fit in the as can be persistent affecting the kind of state for behavior would be potentially threat unsafe to just if you call these class methods and the rope this data at and then we'll build those fast methods and and that's all it really takes look you adapter my right now 1 thing that's really important here is this your eyes method I had little detail and the reason why we call this your eyes Methodist 1st off in in less important as red safety remember remains a shared memory language that has object references so if we have maintained in reference to anything that was passed on to that in the line of that reference when this thing finally go this process later on it is processed in the same process on another thread we running potentially not thread-safe behavior now the normalized pattern makes that not really a big deal but if we summarize the job into a the representation of that mean that like those references and make it thread safe the per region of the and the most important reason is for consistency remember when we want to be able to work with multiple job processes in private and death in even in our tests we wanted to do
so when those job processes are going to persist into the data store such as red as the most Curie-Weiss somehow and this interval will be updated code writers with the original database we have to summarize somehow that that's not so if every job process to create its own sterilization that we could potentially run into problems when we switch between we don't want to have hit in areas where we run this in tests and the running in death and all the serialization works and we run in production different processes the serialization end up fails or does something different so active job provides 1 common serialization routine method and 1 d show this method so all the job processes can choose to serialize the same way and in so doing that will allow that make sure will reduce 1 potential set of errors when we move between job processes so we are going to serialize here even though on you this is that the simplified version and were not storing as in a data store monetarisation make sure we get that consistency across processes z right internally like we said we need to do 2 things we to provide inside the curator of a and so I moved on to the job process and so we have the secured actinometer jump processes the job processes possibility is to provide the basic behavior and they using this behavior is q dependence we want have multiple cues and have each you process a different set of jobs so for this for this we use a it was we need we need to be able to post jobs in a different cues and how they behave asynchronously the reasonable thread 4 that's right because within the context of this simplified application of triple works like a thread pool has its own Q and therefore by creating a separate thread pool for each q we do get a separate queue for these for jobs we just have to map thread hold to q name just men the and then obviously thread-pool has 1 or more threads and therefore provides a behavior so we can very simply deal with the needs of the humanistic is given by the spring federal so worried you here is we're going to create a thread pool but because this is all very a multithreaded and therefore needs be thread-safe Nouri pretty these threads within our our our job pressure self but because rails can be run in a multi threaded web servers we did do go through took the couple hoops in order to get some some threats safety here so we use a concurrent math class this is similar to a Ruby hash and sports API is but it has some additional behavior that 1 it's thread-safe it also has addition additional behaviors make that work but although most of you know that with reviews hash when you create a new hash you can pass the block the initializer and that block will be called after the not exist and that blocking the Spanish life that he was so we're going to do is we're whenever we try and retrieve a thread pool from are mapping of cues offered it doesn't exist we create a new thread and at times will easily create or threats you are as new cues are immediately on has it either other indices you 1 way that you might so this idea that size this is a necessary thing or provide the radii atomicity and synchronicity that we need to have in order to create this new threat there ahead of it's a man of so currency needs therefore the end result is that they things like creating a half she was a however locked in the structure and there have a thread-pool class in this case we just that with a cached thread pool triples that catapulted so those kind of thread we can create on rather than getting into the details of all variety of basically a cached thread pool has an on you slice it will grow and add more threads is needed and with rest become idle at certain down and remove them see what we over time of the optimal number of threats and which for our and simplify processes fine yeah right now I mentioned in human method inside a job process toolkit that basically and mean q this job and what are the cute weird 1 time simply offer whole know the job is to the threat and when the thread was not political active job-based xt that's the important predator active job-based execute on the 1st line became Israel's if you post that's is giving them the fertile pretty you want necessary than hosting that to be won by the thread pool whenever the front was available the active based execute is responsible for for actually at work on by entering the job looking up our specific class to process that job and then posting in calling the performed method on an instance of that in passing in the arguments OK so when you in your classroom hours so we create
that perform at that and it takes a set of arguments it runs active job job-based handles the interrogation of the job pretty instance that in calling that that all we need to do is call the execute on that in our when a thread pool takes Texas and runs it later on and that's all it takes an active job handles that highlights the the internals of that and that right there is enough for us to actually post asynchronous jobs that form a set way in a real environment now for the in Q for later it was really more complicated right now and into the time so you're gonna commit suddenly we do have arrows
Ozal a high-level abstraction that handles these kinds of digital texts and this then leads calls fiddle text right so the intervals little Taskar for beyond the scope of this but the idea is a scandal task would take a number of seconds in the future they something is supposed to occur and it will queued up and it will at that roughly half time it will then pass on the thread will make it work but we also know what we we notice when we actually use are performed at and we use that set method might adapt the rails provides a lot of convenience things for allowing us to specify when the job happens the future right reals gives us all those great time helpers that we're like you 1 day from now on you know I have 1 week from now on at certain times and so forth active job is responsible for taking all of those can these things that we use a lot developers and convert them into a number of seconds in the future in this once it's about time we get this we already have a number of sectors in the future so in our job process that have or about all of those those wonderful utilities rails has real says that for so in this case it's really convenient for us because that'll task not coincidentally takes just a list a number of 2nd Futuna thing to run and in this case are normally within concurvity all of the high-level abstractions element with redpolls so you have to worry about managing a thread calls in fact most developers should never use of frightful directly right most libraries provide thread pools provide and internally and provide high-level abstractions that uses redpolls so normal circumstances histidyl taskbar future promise these things do the global threat or in this case we need a specific foreign people because that report and circular fine understood all the high-level abstractions incurred Ruby support tendency injection of just for regular part of this case as the most accurate which is very common and that is way saying we need you run this thing running on this specific threat so you're doing here is saying what we know how many seconds in the future this thing is to run we we know what's right we want to run on just going handle that spittle task handle the time the thing it's the wrong people then grabbed that job and run this what is really the same thing we did before just active job base but that execute that xt method does not require about the same as the data it is known now the time to execute that has long been assigned to go and and just in case we somehow get a time value that's not something you're not ready this check that the way in no posted directly at the is about the future and that's all it takes little less later on Rails handles all the time sensitive stuff tremendously we to make sure that we can do it at that time in the future right and we're not that in its entirety is a functional of bases organizational process so this was our denoising have a break points when we're out of an emergency and know 1 slide that what you see just how simple this can actually be that in fact is the real make a job process can have that fit on 1 slide this is basically a class called inside job we have our our er cues considering and we're we have this thread-safe map were really keep track of all of our thread pools we have the crate thread-pool method which is returned . 1 we have our and q behavior which Sister Rosa job onto the threat for the even and Q at which actually looks at that the later timestamp and and give it to a scandal task and that right there is actually a fully functioning asynchronous job processes that floods the that can work with active job and like this said the other part was the the island the q adapter remember the queued up just looks like this right it was
simply when active job calls and pure and Q are simply as they to my job process so that sets of we're not that is actually a set a fully functional basing job processor that will work with active job and could be used in tests for development in order to actually patients behavior without having to install reticence under deep dependencies so the next question probably ask is by Jerry unit the dispute upon wasn't and look at a later right and the answer is yes if you wanna see this code we can find a very convenient place and that's ribs the genesis of this presentation was that last fall I went to the rebels and no be really useful if we had a simple basic this job processor in real spot or as you all know we can in our configs specify the inline detector the inline adapter will grow and it will run the job synchronously so we don't have to do with those underneath dependencies but the problem with that is it's not real seekers behavior and for using the inline adapter in tests were development we can sometimes mask problems by not having relations behavior this is what is build a simple 1 and its local asynch job will make the set of instances inside of a decent job will make the symbol just like a sink and when we allow people in tasks and then have to run the really asynchronously in order to potentially find bugs in the real thing said that's a really good idea and they worked with me and we got this was merged into real slide last fall to use real fibrous 5 and use the casing processor this is basically we have this code was lifted almost line by line from the original implementation of that the now since then the real thing the sensory refactoring on that of your look at completion of a little bit differently so just gives a context she different and they decided classes in 1 file Mariza wrote this I 2 files 1 for the acute after 1 the job processor to her mirror that that normal behavior you would have the q adapter in the process of being separate they collapsed in 1 file because array shortened immunity to are there remains some stuff but to go along with that of better reals conventions and they are assigned a provide job ID again in this case we're not really meeting at but having that does again I provide for greater consistency with the production ones but in they they cited a thorough 1 thread pool for everything inexpensive having multiple cues right on because again in test how we care that these things happen some of synchronously we don't particularly care about configuring the cues for for various that behavior so you look at it now dissociation job and it will do exactly what we showed before it's right now available in real life so if I picture interest in you wanna learn more about this and see other things you can do with this are the 2 things I suggest you look at more deeply a sucker punch and psychic that sucker punches a
threat in memories and result processor does a lot of what this does because that way better and more and more fully on the the the creator vessels with the main use case if you want to send e-mails from a a way of hosting provider a 1 to Costa brighter like Rocha you can fire out these e-mails is not lot of high cost of failure affecting the goes down and so those jobs just retain in memory not persistently a datastore but sucker . dies used thread pools just like this because it doesn't matter those q names to thread pools improvised configuration those those are the symbolical things word decorates every job with a job or under class that a certain cool things like tracking of successful jobs track number failed jobs handle errors and do things this is just a really good example heightened decorate a job when you push it into a thread pool and it's really cool things like a said for most of us we should use triples directly the high-level abstractions in the concurrence survivors provide capabilities and this is really good example hiking do that but it also suffer points this really cool shut behavior where if the rails after shutdown for some reason it will look at the number of the jobs is still running in and try and allow the jobs to to make that execute completely before shutting down as some other things so some cool stuff in and ca . uses a lot of the tools that we saw in here uses occurred thread tools it uses the Ruby scandal test on another it 1 is of course I could so I think it's also in memory of me that's also a multithreaded job processor it does not use of it does persist all stuff to a data store so that way your job data will persist beyond a restart of the application it is not used thread pools sigh here on-site psychic actually sponsors own threads and manages its own threads but it's still deals of all the same thing the internals of of active job and of course I think has a whole bunch of additional features are makes it psychic doesn't use the Kurdish triples but does use some use Kirby from the low-level synchronization and and on atomicity stuff threats it's stuck inside here so that you read examples if you want to look at this further the go look at those code bases and see beyond and what we've done here so with that but this was saying
and I work protest double and we all are hiring and we're also for higher so if you really love talking people that suffered element and about after about how we can all proofs software so it's not a chat with us by all means to reach out to us you can find as an e-mail social media on myself and just to be here for the rest of the conference in fact just will be speaking on Thursday in the afternoon at 3 30 and the he's the time are stacked rail spot and so i that stickers up here that's the reason might be and I hope that you talk with you sometime before the provinces over the variables in my name is judy Antonio you for having few so you have 5 minutes if anybody has questions as you in the run-up that's cool number 2 so so the question was a resource contention with image of itself if you have multiple threads running simultaneously and trying to do things on all of the cases investigators provided by the job processes so so all active job does provide a compatibility layer FIL is important that the job processes of cells handle all the concurrency any kind of Y under the position is necessary but generally speaking if you follow the best practices in light of that contention goes away supratemporal not passing Active Record object passing an ID which you can then use to to sample up later on which the arts to the right of of storing resources but but ultimately it is up to the job crosses the itself to be thread-safe so question was would you be bodies multiple job processes simultaneously and the answer is yes but not through active job active job only largest best by 1 handler however ministry ball as far as I know all of the most bizarre sort of all of the job processes fear form can be used outside the context of active job their so the example you might specify units psychic from a your main job processor but say for certain things you when you sucker punch you would then just instance sucker punch directly and so you can do that way I'm and I don't know I I can't imagine why rails would we change at the end it's very possible I so the this to be subclass active job interval runners I think we've got this gets really about anything we want but you this as 1 configuration value with on the application if it I guess we could specify young and course regret figuration evaluations creates new ones are fewer of those and do something about it but I'm sure the ossible but it's not so that we directly reason supported by rails acted on itself is a multivariate system you have multiple threads and a thread was a christmas differently multithreading in general a thread or a thread pool is a manage time thing where the q and all the threads are managed by the object itself that's 1 of the things they said the so I could spawn my threats speckling thread that new right what happens those cracked happens about what new threats what happens if I have idle threats if you have a wife and q those things there is a lot of plumbing involved in that we always on multiple threads but in order to manage that there's a lot of extra stuff how we handle exceptions right the 3rd exception under threat and crashed the threat to handle that so thread-pool takes all of that puts it in 1 object with some very well known are very common Crossland algorithms in many users think secret a thread will you given a set of integration parameters things like how many threads to run a minimum hamming maximum how many the univariate to achieve its full what you do with if you can do that now system give you more threads with you and it handles all that for you so all you do is discrete this 1 abstraction that thrive on it and you throw stuff had and it manages all of that in queuing and you have a minor migration threads crashes handle and so forth your so some of you it was that kind of the there is some overhead in the thread will solve because all of them but it's a any else that overhead comes at the the value of making not worry about those things right to just let you store the high-level abstractions that use the thread pools listed under about that then maybe later on we specify rules triples and inject them into and out of control and then you know I don't really mind if you this guy over there he decided that yourself but that's that's sort of progression and that is a family of question the question how that handle exceptions what we did here does not handle exceptions very well at all right the thread pool itself will protect itself from any kind of exception on the thread that's a threat will not allow its threats to diagnose observations from the triple than do much with than the right this is where the reasons use that are related use a high-level abstractions that is if you use a future promises about all this and those things have consistent on your humanity ways of handling things that return values and and on the errors also for so if you look at and Socrates labels you if the job decorator class in there actually handles the extension is literally a section on the right itself was very or bubbles up and then doing things with it so again I Japanese are the older will provide you with better error handling inconsistency pneumatic in record of wasn't around values and and my mother and timing of the earth and again that's why chinoiserie highly abstractions that only in Java tool and is meant to be the very lowest level analysis provides for essentially said the the actual job processes itself as being handled things like errors right if you look at what happens with 1 of those bridge operative used they are doing very well in this case because this is the bare bones minimum I'm not killing errors end up to discuss jobs have dialectal that again this is meant to be minimal trivial there but if you use when want the full blown I production-ready John and they will handle the decoration that job they will handle the areas and they will have their own way of coming by you'd follow that of the present day the active job did not include it is in a consistent way of handling errors of course you could always at own error handling in non-formal haven't met and handle it there but at a job doesn't really do that for a why would you want to be in terms of for production of the ones are out there are very fantastic the ring that these lot I 1 and the reason for this 1 was to quality will not be rails itself so that for development and testing you can run not heavily also inversely and get a better understanding of how the inner working production on Monday have talked a lot of people in like 1 of the if you go back that and you look at the actual discussion around the the yard is actually a heating itself is right here at this area and generally installs sucker punched for dead and test to be nice if I could just do that with realist not have dedicated appendices sucker punches great of work with them on your brand a greater sucker punch and he's he's fantastic but it's a picture dependency for just dead and test on rails done a great job of writing the the in 1 adapter for dead and test so it makes sense rules pride that simple asynch and and so we just near minimized what we actually need and put it on rails itself so now 4 Devon test do that out and get a better sense the real behavior in production would likely I have to do the it's in real 5 now yeah so excited using real 5 is to say a sink and in your could face there Chelsea check their answers uh pH if the the money I might call it
Nachbarschaft <Mathematik>
Bit
Programmiergerät
Prozess <Physik>
Mereologie
Datenparallelität
Gruppenoperation
Sprachsynthese
Kombinatorische Gruppentheorie
Computeranimation
Textverarbeitung
Lochstreifen
Hydrostatik
Weg <Topologie>
Wechselsprung
Task
Softwaretest
Parallelrechner
Fächer <Mathematik>
Prozess <Informatik>
Softwarewartung
Mustersprache
Elektronischer Programmführer
Parallele Schnittstelle
Softwaretest
Elastische Deformation
Prozess <Informatik>
Biprodukt
Quick-Sort
Ordnungsreduktion
Software
Datenparallelität
Projektive Ebene
Information
Standardabweichung
Einfügungsdämpfung
Komponententest
Extrempunkt
Mengenfunktion
t-Test
Abstraktionsebene
Computeranimation
Homepage
Metadaten
Softwaretest
Elektronischer Programmführer
E-Mail
Softwaretest
Suite <Programmpaket>
Kategorie <Mathematik>
Varietät <Mathematik>
Biprodukt
Akkumulator <Informatik>
Scheduling
Rechter Winkel
Einheit <Mathematik>
Festspeicher
Server
Ordnung <Mathematik>
Programmierumgebung
Fitnessfunktion
Instantiierung
Subtraktion
Lochstreifen
Hyperbelverfahren
Klasse <Mathematik>
Fluss <Mathematik>
Datenhaltung
Informationsmodellierung
Bildschirmmaske
Reelle Zahl
Endogene Variable
Thread
Installation <Informatik>
Cluster <Rechnernetz>
Konfigurationsraum
Stochastische Abhängigkeit
Soundverarbeitung
Konvexe Hülle
Symboltabelle
Thread
Prozess <Physik>
Datenparallelität
Kartesische Koordinaten
Textverarbeitung
Übergang
Lochstreifen
Wechselsprung
Einheit <Mathematik>
Datenmanagement
Maßstab
Prozess <Informatik>
Gamecontroller
Bildschirmfenster
Figurierte Zahl
Parallele Schnittstelle
Zentrische Streckung
Lineares Funktional
Parametersystem
Abstraktionsebene
Datenhaltung
Stellenring
Systemaufruf
Konfiguration <Informatik>
Framework <Informatik>
Refactoring
Anpassung <Mathematik>
Scheduling
p-Block
Textverarbeitung
Schlüsselverwaltung
Zentraleinheit
Varietät <Mathematik>
Nebenbedingung
Metadaten
Zahlenbereich
Implementierung
Gebäude <Mathematik>
Kombinatorische Gruppentheorie
ROM <Informatik>
Term
Code
Framework <Informatik>
Task
Benutzerbeteiligung
Multiplikation
Datensatz
Task
Front-End <Software>
Arbeitsplatzcomputer
Warteschlange
Softwareentwickler
Speicher <Informatik>
Leistung <Physik>
Trennungsaxiom
Relationale Datenbank
Graph
Objektklasse
Ordnungsreduktion
Quick-Sort
Endogene Variable
Warteschlange
Objekt <Kategorie>
Mapping <Computergraphik>
Dreiecksfreier Graph
Mereologie
Normalvektor
Resultante
Quelle <Physik>
Vektorpotenzial
Prozess <Physik>
Datenparallelität
Gemeinsamer Speicher
Minimierung
Natürliche Zahl
Formale Sprache
Selbstrepräsentation
Versionsverwaltung
Kartesische Koordinaten
Superposition <Mathematik>
Synchronisierung
Computeranimation
Metadaten
Wechselsprung
Prozess <Informatik>
Mustersprache
Zeitstempel
Default
Gerade
Metropolitan area network
Softwaretest
Parametersystem
Addition
Sichtenkonzept
Kategorie <Mathematik>
Datenhaltung
Güte der Anpassung
p-Block
Kontextbezogenes System
Biprodukt
Scheduling
Druckverlauf
Polarisation
Menge
Rechter Winkel
Datenparallelität
Anpassung <Mathematik>
Server
Decodierung
Information
Ordnung <Mathematik>
Textverarbeitung
Varietät <Mathematik>
Instantiierung
Aggregatzustand
Fehlermeldung
Subtraktion
Hash-Algorithmus
Kontrollstruktur
Mathematisierung
Klasse <Mathematik>
Zahlenbereich
Ordinalzahl
Code
Zeitstempel
Benutzerbeteiligung
Multiplikation
Hash-Algorithmus
Endogene Variable
Koroutine
Thread
Warteschlange
Indexberechnung
Speicher <Informatik>
Datenstruktur
Maßerweiterung
Softwareentwickler
Widerspruchsfreiheit
Attributierte Grammatik
Trennungsaxiom
Radius
Videospiel
Default
Softwarewerkzeug
Elektronischer Datenaustausch
Physikalisches System
Objektklasse
Quick-Sort
Warteschlange
Objekt <Kategorie>
Thread
Flächeninhalt
Caching
Mereologie
Differentialgleichungssystem
Attributierte Grammatik
Serielle Schnittstelle
Sensitivitätsanalyse
Prozess <Physik>
Punkt
Klasse <Mathematik>
Zahlenbereich
Element <Mathematik>
Computeranimation
Zeitstempel
Task
Weg <Topologie>
Reelle Zahl
Prozess <Informatik>
Programmbibliothek
Zeitrichtung
Kontrollstruktur
Stützpunkt <Mathematik>
Thread
Strom <Mathematik>
Softwareentwickler
Parametersystem
Abstraktionsebene
Default
Zwei
Softwarewerkzeug
Systemaufruf
Mailing-Liste
Warteschlange
Mapping <Computergraphik>
Rechenschieber
Menge
Rechter Winkel
Digitalisierer
Datenparallelität
Injektivität
Mereologie
Programmierumgebung
Fitnessfunktion
Resultante
Bit
Punkt
Prozess <Physik>
Datenparallelität
Kartesische Koordinaten
Gerichteter Graph
Synchronisierung
Service provider
Computeranimation
Lochstreifen
Eins
Einheit <Mathematik>
Prozess <Informatik>
Stützpunkt <Mathematik>
E-Mail
Gerade
Softwaretest
Addition
Vervollständigung <Mathematik>
Abstraktionsebene
Systemaufruf
Kontextbezogenes System
Biprodukt
Rechenschieber
Menge
Festspeicher
Refactoring
Ordnung <Mathematik>
Textverarbeitung
Refactoring
Fehlermeldung
Instantiierung
Lochstreifen
Klasse <Mathematik>
Zahlenbereich
Ordinalzahl
Kombinatorische Gruppentheorie
Code
Zeitstempel
Task
Service provider
Weg <Topologie>
Fermatsche Vermutung
Reelle Zahl
Thread
Installation <Informatik>
Speicher <Informatik>
Softwareentwickler
Konfigurationsraum
Widerspruchsfreiheit
Implementierung
Videospiel
Relativitätstheorie
Symboltabelle
Elektronische Publikation
Programmfehler
Verdeckungsrechnung
Thread
ROM <Informatik>
Fibonacci-Folge
Wort <Informatik>
Normalvektor
Prozess <Physik>
Datenparallelität
Extrempunkt
Familie <Mathematik>
Kartesische Koordinaten
Bridge <Kommunikationstechnik>
Eins
Übergang
Algorithmus
Datenmanagement
Prozess <Informatik>
E-Mail
Figurierte Zahl
Softwaretest
Parametersystem
Abstraktionsebene
Ausnahmebehandlung
Biprodukt
Kontextbezogenes System
Menge
Rechter Winkel
Beweistheorie
Garbentheorie
Ordnung <Mathematik>
Textverarbeitung
Overhead <Kommunikationstechnik>
Fehlermeldung
Instantiierung
Lochstreifen
Ortsoperator
Klasse <Mathematik>
Zahlenbereich
Zellularer Automat
Systemzusammenbruch
Term
Multiplikation
Variable
Bildschirmmaske
Datensatz
Unterring
Arithmetische Folge
Reelle Zahl
Software
Migration <Informatik>
Stichprobenumfang
Vererbungshierarchie
Luenberger-Beobachter
Installation <Informatik>
Thread
Inhalt <Mathematik>
Softwareentwickler
Maßerweiterung
Drei
Konfigurationsraum
Bildgebendes Verfahren
Widerspruchsfreiheit
Leistungsbewertung
Analysis
Schlussregel
Physikalisches System
Quick-Sort
Integral
Objekt <Kategorie>
Flächeninhalt
Hypermedia
Gamecontroller
Innerer Punkt

Metadaten

Formale Metadaten

Titel Inside ActiveJob
Serientitel RailsConf 2016
Teil 30
Anzahl der Teile 89
Autor D'Antonio, Jerry
Lizenz CC-Namensnennung - Weitergabe unter gleichen Bedingungen 3.0 Unported:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen und nicht-kommerziellen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen und das Werk bzw. diesen Inhalt auch in veränderter Form nur unter den Bedingungen dieser Lizenz weitergeben.
DOI 10.5446/31528
Herausgeber Confreaks, LLC
Erscheinungsjahr 2016
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract ActiveJob made a huge impact when it landed Rails 4.2. Most job processors support it and many developers use it. But few ever need to dig into the internals. How exactly does ActiveJob allow us to execute performant, thread-safe, asynchronous jobs in a language not known for concurrency? This talk will answer that question. We'll build our own asynchronous job processor from scratch and along the way we'll take a deep dive into queues, job serialization, scheduled tasks, and Ruby's memory model.

Ähnliche Filme

Loading...