| 1 |
| 00:00:05,000 --> 00:00:11,000 |
| Hello, yes, students today will start learning a new topic, Moonface Riden, this is huge topic, |
|
|
| 2 |
| 00:00:11,000 --> 00:00:16,000 |
| and after this course, you will have a lot of knowledge that you can apply in different programming |
|
|
| 3 |
| 00:00:16,000 --> 00:00:21,000 |
| languages to support not just execution, but in scope of this course. |
|
|
| 4 |
| 00:00:21,000 --> 00:00:27,000 |
| I will show you how MultiThreaded works on Java examples and take into account this is the first lesson |
|
|
| 5 |
| 00:00:27,000 --> 00:00:32,000 |
| of new topic, this lesson a little bit more theoretical one to be sure that we have enough high level |
|
|
| 6 |
| 00:00:32,000 --> 00:00:37,000 |
| knowledge and understanding before we'll start sharing, quote, examples in the next lesson. |
|
|
| 7 |
| 00:00:37,000 --> 00:00:43,000 |
| That's why today we'll focus our attention on such questions as what is the process in our computers? |
|
|
| 8 |
| 00:00:43,000 --> 00:00:45,000 |
| What is the threat of execution? |
|
|
| 9 |
| 00:00:46,000 --> 00:00:52,000 |
| What is multithreaded in programming also in this lesson and explain how multiscreen works and what |
|
|
| 10 |
| 00:00:52,000 --> 00:00:54,000 |
| threats and translation means. |
|
|
| 11 |
| 00:00:54,000 --> 00:00:59,000 |
| And the standard answers on these questions will bring us to the point where we can discuss with you |
|
|
| 12 |
| 00:00:59,000 --> 00:01:02,000 |
| why multiscreen is needed and what a benefit, something which is written. |
|
|
| 13 |
| 00:01:03,000 --> 00:01:09,000 |
| And also we'll discuss dark side of multithreaded to understand it, drawbacks and what we should always |
|
|
| 14 |
| 00:01:09,000 --> 00:01:12,000 |
| take into account while working as much as freedom. |
|
|
| 15 |
| 00:01:12,000 --> 00:01:17,000 |
| And the end of the lesson, I will give you an overview of what packages and tools we are going to learn |
|
|
| 16 |
| 00:01:17,000 --> 00:01:19,000 |
| in this course in JDK. |
|
|
| 17 |
| 00:01:19,000 --> 00:01:25,000 |
| Answering all these questions will give you insights on what we are going to learn in this course. |
|
|
| 18 |
| 00:01:25,000 --> 00:01:27,000 |
| I believe we are good with our agenda for today. |
|
|
| 19 |
| 00:01:27,000 --> 00:01:34,000 |
| Let's start and before we even start discussion of multithreaded in the program, let's understand what |
|
|
| 20 |
| 00:01:34,000 --> 00:01:36,000 |
| the process is in computer science. |
|
|
| 21 |
| 00:01:36,000 --> 00:01:40,000 |
| In simple words, process is an instance of a computer program. |
|
|
| 22 |
| 00:01:41,000 --> 00:01:42,000 |
| You opened a glimpse. |
|
|
| 23 |
| 00:01:42,000 --> 00:01:45,000 |
| It's a separate process to run as a Java program. |
|
|
| 24 |
| 00:01:46,000 --> 00:01:47,000 |
| Is that a separate Java process? |
|
|
| 25 |
| 00:01:48,000 --> 00:01:53,000 |
| Computer program is nothing more than a set of instructions for a machine but process. |
|
|
| 26 |
| 00:01:54,000 --> 00:01:56,000 |
| It is an execution of these instructions. |
|
|
| 27 |
| 00:01:57,000 --> 00:02:00,000 |
| A process has a self-contained execution environment. |
|
|
| 28 |
| 00:02:00,000 --> 00:02:04,000 |
| That means that each process has its own memory space. |
|
|
| 29 |
| 00:02:05,000 --> 00:02:10,000 |
| And as I said before, usually processes and programs are considered to be very close terms. |
|
|
| 30 |
| 00:02:11,000 --> 00:02:18,000 |
| But what end user interaction with may be a set of processes that interact with each other doing no |
|
|
| 31 |
| 00:02:18,000 --> 00:02:21,000 |
| such popular Internet browser as Google Chrome? |
|
|
| 32 |
| 00:02:21,000 --> 00:02:24,000 |
| So long to go home and look at the task manager. |
|
|
| 33 |
| 00:02:25,000 --> 00:02:28,000 |
| You will see separate processes for each stop in your browser. |
|
|
| 34 |
| 00:02:28,000 --> 00:02:33,000 |
| But for the end user, Manglehorn perceived like a single application. |
|
|
| 35 |
| 00:02:33,000 --> 00:02:40,000 |
| This is because most operating system support interpersonal communication resources, sap, pipes and |
|
|
| 36 |
| 00:02:40,000 --> 00:02:41,000 |
| sockets. |
|
|
| 37 |
| 00:02:41,000 --> 00:02:47,000 |
| These resources are used to interact between different processes, homes, and this is pretty straightforward. |
|
|
| 38 |
| 00:02:48,000 --> 00:02:51,000 |
| Now let's understand what threat of execution is. |
|
|
| 39 |
| 00:02:51,000 --> 00:02:56,000 |
| Each process may be executed in one or more threats of execution. |
|
|
| 40 |
| 00:02:56,000 --> 00:02:59,000 |
| In this case, our program is executed concurrently. |
|
|
| 41 |
| 00:02:59,000 --> 00:03:03,000 |
| In other words, some instructions are executed in parallel. |
|
|
| 42 |
| 00:03:03,000 --> 00:03:09,000 |
| In computer science, concurrency is a duplicate of different parts or units of a program algorithm |
|
|
| 43 |
| 00:03:10,000 --> 00:03:17,000 |
| or problem to be executed out of order or at the same time simultaneously without affecting the final |
|
|
| 44 |
| 00:03:17,000 --> 00:03:17,000 |
| outcome. |
|
|
| 45 |
| 00:03:18,000 --> 00:03:22,000 |
| So we can say that each process may be executed in multiple threats. |
|
|
| 46 |
| 00:03:23,000 --> 00:03:27,000 |
| In the learning literature, you might even find mention about different name of abstracts. |
|
|
| 47 |
| 00:03:27,000 --> 00:03:34,000 |
| Sometimes they're called as lightweight processes or threats, share process resources. |
|
|
| 48 |
| 00:03:34,000 --> 00:03:37,000 |
| This is something that may cause issues during the multithreaded. |
|
|
| 49 |
| 00:03:38,000 --> 00:03:44,000 |
| If you're allocated two gigabytes for a GBM, that means all created stress will work within these two |
|
|
| 50 |
| 00:03:44,000 --> 00:03:47,000 |
| gigabytes and we'll share in between each other. |
|
|
| 51 |
| 00:03:48,000 --> 00:03:51,000 |
| Knowing your memory will be allocated to threat of execution. |
|
|
| 52 |
| 00:03:52,000 --> 00:03:54,000 |
| I hope you already know the answer to my next question. |
|
|
| 53 |
| 00:03:55,000 --> 00:03:56,000 |
| What is a move to threaten? |
|
|
| 54 |
| 00:03:57,000 --> 00:04:01,000 |
| To threaten is the process of execution of program in multiple threats. |
|
|
| 55 |
| 00:04:01,000 --> 00:04:04,000 |
| Most of the operating systems nowadays support this feature. |
|
|
| 56 |
| 00:04:05,000 --> 00:04:11,000 |
| You have multiple course in your processa multithreaded allows you to use all course for execution of |
|
|
| 57 |
| 00:04:11,000 --> 00:04:13,000 |
| your program instructions. |
|
|
| 58 |
| 00:04:13,000 --> 00:04:21,000 |
| EPU executes one task at a time and we as the software engineers will write instructions how to split |
|
|
| 59 |
| 00:04:22,000 --> 00:04:23,000 |
| between different threats of execution. |
|
|
| 60 |
| 00:04:24,000 --> 00:04:25,000 |
| That's what we are going to learn. |
|
|
| 61 |
| 00:04:26,000 --> 00:04:27,000 |
| Let me explain it now. |
|
|
| 62 |
| 00:04:27,000 --> 00:04:32,000 |
| How multiscreen program works on the high level, you always have one threat of execution. |
|
|
| 63 |
| 00:04:32,000 --> 00:04:34,000 |
| One program just started. |
|
|
| 64 |
| 00:04:34,000 --> 00:04:36,000 |
| That is your main threat of execution. |
|
|
| 65 |
| 00:04:37,000 --> 00:04:43,000 |
| After that, you can run so-called child threats of execution and describe instructions what those threats |
|
|
| 66 |
| 00:04:43,000 --> 00:04:44,000 |
| should work on. |
|
|
| 67 |
| 00:04:44,000 --> 00:04:48,000 |
| In parallel, the different use cases of using Otis Redding. |
|
|
| 68 |
| 00:04:48,000 --> 00:04:49,000 |
| And we'll look at them in the minute. |
|
|
| 69 |
| 00:04:50,000 --> 00:04:56,000 |
| And now the important thing, how to synchronize the work of different threats imagines at your peril |
|
|
| 70 |
| 00:04:56,000 --> 00:04:58,000 |
| to your work between multiple threats. |
|
|
| 71 |
| 00:04:59,000 --> 00:05:00,000 |
| It is another thing that. |
|
|
| 72 |
| 00:05:00,000 --> 00:05:06,000 |
| All of the threats are part of one program, and sometimes threat needs to update on the man's threat |
|
|
| 73 |
| 00:05:06,000 --> 00:05:09,000 |
| about state of execution or result of execution. |
|
|
| 74 |
| 00:05:10,000 --> 00:05:15,000 |
| But sometimes threats also need to interact with each other, take into account all threats, working |
|
|
| 75 |
| 00:05:15,000 --> 00:05:17,000 |
| with some shared resource. |
|
|
| 76 |
| 00:05:17,000 --> 00:05:23,000 |
| To rephrase this in simple words, imagine that you have a collection of users and you need to filter |
|
|
| 77 |
| 00:05:23,000 --> 00:05:28,000 |
| this collection and remove users that have less than one thousand dollars total. |
|
|
| 78 |
| 00:05:28,000 --> 00:05:34,000 |
| Check in your online shop and you decided to split the task between different threats of execution. |
|
|
| 79 |
| 00:05:34,000 --> 00:05:39,000 |
| Each threat of execution works with shared resource collection of users. |
|
|
| 80 |
| 00:05:39,000 --> 00:05:46,000 |
| Each threat takes users from this common collection to provide the result of the specific part of namely |
|
|
| 81 |
| 00:05:46,000 --> 00:05:53,000 |
| users are equally distributed between different threats but all threats to removing users from the common |
|
|
| 82 |
| 00:05:53,000 --> 00:05:55,000 |
| collection shared between all of them. |
|
|
| 83 |
| 00:05:55,000 --> 00:05:59,000 |
| Can you understand what the shared resource mean on this example? |
|
|
| 84 |
| 00:06:00,000 --> 00:06:05,000 |
| Let's review also other use cases of multithreaded programming and the one we might want to use this |
|
|
| 85 |
| 00:06:05,000 --> 00:06:05,000 |
| approach. |
|
|
| 86 |
| 00:06:06,000 --> 00:06:08,000 |
| I believe that we have already discussed the first case. |
|
|
| 87 |
| 00:06:09,000 --> 00:06:15,000 |
| That is the case when different threats on these slides are marked with capital key and numbers reaching |
|
|
| 88 |
| 00:06:15,000 --> 00:06:22,000 |
| out to shared resource that is marked with capital are in this case to modify the state of the resource. |
|
|
| 89 |
| 00:06:23,000 --> 00:06:27,000 |
| So next year's case of using multithreaded is reading and writing operations. |
|
|
| 90 |
| 00:06:28,000 --> 00:06:33,000 |
| You know that in Java, most of the input output streams, blogs and in process of execution. |
|
|
| 91 |
| 00:06:34,000 --> 00:06:37,000 |
| So why don't we use features of malicious reading? |
|
|
| 92 |
| 00:06:37,000 --> 00:06:42,000 |
| And in case we need to write, let's say, some file, we do this in a separate thread. |
|
|
| 93 |
| 00:06:42,000 --> 00:06:50,000 |
| For example, a user asked us to do an expert of all users to see format and wants to download this |
|
|
| 94 |
| 00:06:50,000 --> 00:06:50,000 |
| info. |
|
|
| 95 |
| 00:06:50,000 --> 00:06:52,000 |
| No problem at all. |
|
|
| 96 |
| 00:06:52,000 --> 00:06:58,000 |
| We are writing a separate threat of execution and other parts of our program proceed, working without |
|
|
| 97 |
| 00:06:58,000 --> 00:07:05,000 |
| any free's user still able to click on other buttons and perform other operations while file downloading |
|
|
| 98 |
| 00:07:05,000 --> 00:07:06,000 |
| is in progress. |
|
|
| 99 |
| 00:07:06,000 --> 00:07:07,000 |
| Is that clear? |
|
|
| 100 |
| 00:07:07,000 --> 00:07:09,000 |
| Same situation with redundant info. |
|
|
| 101 |
| 00:07:10,000 --> 00:07:16,000 |
| Let's create a separate threat of execution that will show a status of uploading, and once uploading |
|
|
| 102 |
| 00:07:16,000 --> 00:07:21,000 |
| is finished, we will be notified about that fact and we'll proceed from there. |
|
|
| 103 |
| 00:07:21,000 --> 00:07:27,000 |
| Pay attention to how your clips is working when your important project or performance some other operations. |
|
|
| 104 |
| 00:07:28,000 --> 00:07:32,000 |
| Eclipse is also Java application was multithreaded feature inside. |
|
|
| 105 |
| 00:07:32,000 --> 00:07:39,000 |
| When any operation is performed, UI is not completely blocked and you still can perform as operations |
|
|
| 106 |
| 00:07:39,000 --> 00:07:40,000 |
| with the clips in parallel. |
|
|
| 107 |
| 00:07:41,000 --> 00:07:47,000 |
| The third case is a case when once to produce some data and other thread consumes this data. |
|
|
| 108 |
| 00:07:48,000 --> 00:07:54,000 |
| These threads are working independently and potentially may interact with the help of the queue between |
|
|
| 109 |
| 00:07:54,000 --> 00:07:54,000 |
| each other. |
|
|
| 110 |
| 00:07:55,000 --> 00:08:02,000 |
| On the slide here you can see that we have producer and consumer producer send some item ready for processing |
|
|
| 111 |
| 00:08:02,000 --> 00:08:08,000 |
| to the queue and consumer take this item from the queue when ready to process the next item. |
|
|
| 112 |
| 00:08:08,000 --> 00:08:12,000 |
| The next case is a typical scenario with writers and readers. |
|
|
| 113 |
| 00:08:13,000 --> 00:08:19,000 |
| Imagine that you have some shared resource, some shared buffer, and from one side you have writers |
|
|
| 114 |
| 00:08:19,000 --> 00:08:21,000 |
| that might be separate services. |
|
|
| 115 |
| 00:08:21,000 --> 00:08:24,000 |
| Read that, write some information to the buffer. |
|
|
| 116 |
| 00:08:24,000 --> 00:08:28,000 |
| It can be is a strong representation of new objects or requests to the app. |
|
|
| 117 |
| 00:08:28,000 --> 00:08:30,000 |
| Literally everything. |
|
|
| 118 |
| 00:08:30,000 --> 00:08:34,000 |
| And on the other side, you have readers that read data from the buffer. |
|
|
| 119 |
| 00:08:35,000 --> 00:08:41,000 |
| This example is different from all previous ones that we have discussed because here we have some specific |
|
|
| 120 |
| 00:08:41,000 --> 00:08:47,000 |
| conditions on the ones that can write to the buffer at the point of time readers can to read during |
|
|
| 121 |
| 00:08:47,000 --> 00:08:53,000 |
| the writing, all the readers may read data simultaneously, will have similar tasks in this course. |
|
|
| 122 |
| 00:08:53,000 --> 00:08:56,000 |
| And I will show you how to solve this task. |
|
|
| 123 |
| 00:08:56,000 --> 00:08:58,000 |
| Really interesting, don't you think so? |
|
|
| 124 |
| 00:08:59,000 --> 00:09:03,000 |
| Probably these are the most popular use cases of using an Otis Redding approach. |
|
|
| 125 |
| 00:09:03,000 --> 00:09:10,000 |
| Definitely there will be variations of these use cases and sometimes even different scenarios, but |
|
|
| 126 |
| 00:09:10,000 --> 00:09:13,000 |
| we'll try to cover as much as we can on this course. |
|
|
| 127 |
| 00:09:13,000 --> 00:09:17,000 |
| Now let's discuss advantages and disadvantages of multi threading approach. |
|
|
| 128 |
| 00:09:18,000 --> 00:09:20,000 |
| Let's start from advantages of multithreaded. |
|
|
| 129 |
| 00:09:20,000 --> 00:09:22,000 |
| It was to name a few important ones. |
|
|
| 130 |
| 00:09:22,000 --> 00:09:29,000 |
| They are effective use of multiple course of your processa, high performance of your program during |
|
|
| 131 |
| 00:09:29,000 --> 00:09:32,000 |
| execution of specific operations and data processing. |
|
|
| 132 |
| 00:09:33,000 --> 00:09:36,000 |
| Good to use with operations that block mansard of execution. |
|
|
| 133 |
| 00:09:37,000 --> 00:09:43,000 |
| Like I said before, in case of working with input output streams, application responsiveness, if |
|
|
| 134 |
| 00:09:43,000 --> 00:09:49,000 |
| there is a need to perform, some operation application won't be frozen until that operation is completed. |
|
|
| 135 |
| 00:09:50,000 --> 00:09:53,000 |
| Instead, I will execute request in a separate thread. |
|
|
| 136 |
| 00:09:54,000 --> 00:10:00,000 |
| Probably these are main advantages of using these advantages, maintaining the Australian approach. |
|
|
| 137 |
| 00:10:00,000 --> 00:10:06,000 |
| Across all over the world and in different programming languages, but there are always two sides of |
|
|
| 138 |
| 00:10:06,000 --> 00:10:10,000 |
| a metal, all these advantages come with a group of disadvantages. |
|
|
| 139 |
| 00:10:10,000 --> 00:10:17,000 |
| Some of them are it is easy to use is written incorrectly by saying this, I would like to highlight |
|
|
| 140 |
| 00:10:17,000 --> 00:10:18,000 |
| that using what is right. |
|
|
| 141 |
| 00:10:18,000 --> 00:10:24,000 |
| And it requires a good understanding of the toolset to implement concurrent execution of your program. |
|
|
| 142 |
| 00:10:24,000 --> 00:10:26,000 |
| And that is relatively easy to do. |
|
|
| 143 |
| 00:10:26,000 --> 00:10:32,000 |
| A mistake, for example, in synchronous court, sometimes also of execution doesn't play a big role. |
|
|
| 144 |
| 00:10:33,000 --> 00:10:39,000 |
| Or you can write code in different ways with the thread and it is not so easy and straightforward. |
|
|
| 145 |
| 00:10:40,000 --> 00:10:46,000 |
| You need to be sure about what pieces of code you need to synchronize between different threads, how |
|
|
| 146 |
| 00:10:46,000 --> 00:10:50,000 |
| much stress you need, how to split work between threads and so on. |
|
|
| 147 |
| 00:10:50,000 --> 00:10:55,000 |
| Incorrect and suitable usage of Montasser in May cause your performance. |
|
|
| 148 |
| 00:10:56,000 --> 00:11:00,000 |
| You need to understand that multithreaded works perfectly, not for all tasks. |
|
|
| 149 |
| 00:11:01,000 --> 00:11:06,000 |
| For example, you might not always see the benefit of using what is written while working with small |
|
|
| 150 |
| 00:11:06,000 --> 00:11:12,000 |
| data in case you want to implement a certain approach and filter an election was one hundred integers. |
|
|
| 151 |
| 00:11:12,000 --> 00:11:18,000 |
| More likely, it will take more time than performing the same operation synchronously in one step. |
|
|
| 152 |
| 00:11:19,000 --> 00:11:19,000 |
| Why? |
|
|
| 153 |
| 00:11:20,000 --> 00:11:26,000 |
| Because running threads, synchronization time, corporatization of different threads on different CPUs. |
|
|
| 154 |
| 00:11:26,000 --> 00:11:31,000 |
| All of this takes time and we need to be sure that when we apply to certain approach, it is really |
|
|
| 155 |
| 00:11:31,000 --> 00:11:38,000 |
| worth it and we will benefit from this and some mistakes even can bring it to the deadlock and lifework |
|
|
| 156 |
| 00:11:38,000 --> 00:11:39,000 |
| cases. |
|
|
| 157 |
| 00:11:39,000 --> 00:11:45,000 |
| When your program doesn't perform any useful activity, hard to debark application and find the mistake, |
|
|
| 158 |
| 00:11:46,000 --> 00:11:52,000 |
| it is much harder to replicate an error in the multithreaded application than it is to do so in a single |
|
|
| 159 |
| 00:11:52,000 --> 00:11:53,000 |
| threaded application. |
|
|
| 160 |
| 00:11:53,000 --> 00:11:58,000 |
| As a result, it is more difficult to identify and verify root causes when error. |
|
|
| 161 |
| 00:11:58,000 --> 00:12:03,000 |
| Secure testing process of multithreaded app is more difficult. |
|
|
| 162 |
| 00:12:03,000 --> 00:12:09,000 |
| Testing the multithreaded application is more difficult than testing a single application because the |
|
|
| 163 |
| 00:12:09,000 --> 00:12:13,000 |
| effects are often timing related and more difficult to reproduce. |
|
|
| 164 |
| 00:12:13,000 --> 00:12:19,000 |
| It is difficult to introduce notice writing approach already created code because all code needs to |
|
|
| 165 |
| 00:12:19,000 --> 00:12:24,000 |
| be analyzed by engineers, static variables, methods and locations and critical areas. |
|
|
| 166 |
| 00:12:24,000 --> 00:12:30,000 |
| Everything needs to be reviewed and adjusted to make sure that the implementation of concurrent programming |
|
|
| 167 |
| 00:12:30,000 --> 00:12:32,000 |
| approach will not affect all application. |
|
|
| 168 |
| 00:12:33,000 --> 00:12:39,000 |
| The main disadvantages of multithreaded that we also need to consider when we want to create scalable |
|
|
| 169 |
| 00:12:39,000 --> 00:12:40,000 |
| app with high performance. |
|
|
| 170 |
| 00:12:41,000 --> 00:12:47,000 |
| In this course, we are going to learn tools for concurrent programming most tools, classes and interfaces |
|
|
| 171 |
| 00:12:47,000 --> 00:12:48,000 |
| allocated in Java. |
|
|
| 172 |
| 00:12:48,000 --> 00:12:50,000 |
| You can current package. |
|
|
| 173 |
| 00:12:50,000 --> 00:12:57,000 |
| This package also has some set packages, also some main types like Runnable and Thread located in general |
|
|
| 174 |
| 00:12:57,000 --> 00:12:58,000 |
| and package. |
|
|
| 175 |
| 00:12:58,000 --> 00:13:05,000 |
| But most of the classes and interfaces, including concurrent collections, locks and other mechanisms |
|
|
| 176 |
| 00:13:05,000 --> 00:13:10,000 |
| for stress synchronization executer services and most of the things that we are going to learn allocated |
|
|
| 177 |
| 00:13:10,000 --> 00:13:12,000 |
| individual concurrent package. |
|
|
| 178 |
| 00:13:12,000 --> 00:13:15,000 |
| We have really a lot of interesting things to learn. |
|
|
| 179 |
| 00:13:15,000 --> 00:13:19,000 |
| Now let's recap what we have learned in this lesson and this lesson. |
|
|
| 180 |
| 00:13:19,000 --> 00:13:22,000 |
| We learned what the process is and what the threat is. |
|
|
| 181 |
| 00:13:23,000 --> 00:13:28,000 |
| We also learned what is a multiscreen program programming now, you know, the most popular use cases |
|
|
| 182 |
| 00:13:28,000 --> 00:13:30,000 |
| of not just training programs. |
|
|
| 183 |
| 00:13:30,000 --> 00:13:34,000 |
| We learned advantages and disadvantages of concurrent programming. |
|
|
| 184 |
| 00:13:35,000 --> 00:13:36,000 |
| That's all for this lesson. |
|
|
| 185 |
| 00:13:36,000 --> 00:13:39,000 |
| Looking forward to seeing you in the next lesson. |
|
|
|
|
