Practical Chapter (1)
Before entering the practical chapter, let’s briefly talk about the general principles of multi-threaded programming.
[Security] is the primary principle of multi-threaded programming. If more than two threads access the same object, one thread will be damaged
The data of another thread violates the principle of security, and such programs cannot enter practical applications.
Security guarantees can be controlled manually by designing secure classes and programmers. If multiple threads access the same object,
It will endanger security. Such classes are thread-safe classes. In JAVA, for example, the String class is designed as a thread-safe class.
If it is not a thread-safe class, then programmers need to manually control its security when accessing instances of these classes.
[Feasibility] is another important principle of multi-threaded programming. If only security is achieved, the program cannot be continued at a certain point.
If continuous execution or multiple threads die locked, such programs cannot be applied as real multi-threaded programs.
Relatively speaking, security and feasibility are mutually incompatible. The higher the security program, the lower the liability guild will be. Comprehensive balance is required.
[High performance] The purpose of multi-threading is to increase the performance of program operation. If a multi-threading work is not completed yet
If a single thread completes quickly, then don’t apply multi-threading.
High-performance programs mainly have the following factors:
Data throughput, processing capability that can be completed within a certain period of time.
Response speed, the time from the time the request is issued to the time when the response is received.
Capacity refers to the number of tasks that are handled at the same time.
Security and feasibility are necessary conditions. If these two principles are not met, it cannot be called a true multi-threaded program.
Highness is the purpose of multi-threaded programming, and it can also be said to be a sufficient and necessary condition. Otherwise, why use multi-threaded programming?
[Producer and Consumer Model]
First, we will enter the first section of the practical chapter with a producer and consumer model.
Who is protected in the producer and consumer model?
Multithreaded programming is protecting certain objects, which are "hungry resources" and must be used to the maximum extent, which is also
Reason for adopting a multi-threaded approach. In the producer-consumer model, what we want to protect is the "repository". In my example below,
It's a table (table)
The model in my example is completely the producer-consumer model, but I changed my name. Chef-die model, this food
There is only 1 table in the hall, and up to 10 plates are placed at the same time. Now there are 4 chefs cooking. Every time a plate is prepared, they are placed on the table (the producer will
The products are placed in the warehouse), and 6 diners keep eating (consumers consume products, and to illustrate the problem, their appetite is unlimited).
Generally speaking, the chef makes a dish at 200-400ms, while the diners have to finish a dish at 400-600ms. When the table is filled with 10
After a plate, all the chefs could no longer put it on the table, and when the table had no plates, all the diners had to wait.
Let’s design this program below:
Because we don’t know what kind of dish it is, we call it food:
class Food{}
Then there is the table, because it must be placed in an orderly manner and taken in an orderly manner (two diners cannot compete for the third dish at the same time), so we
Extending LinkedList, or you can use a LinkedList as a property to achieve the same goal. In the example, I use it
Inheritance, pass in a maximum value that can be placed from the constructor method
class Table extends {
int maxSize;
public Table(int maxSize){
= maxSize;
}
}
Now we need to add two methods to it, one is the method of the chef putting the dishes on it, and the other is the method of the diner picking the dishes from the table.
Putting dishes: Because multiple chefs put dishes on a table, the chef's put dishes must be synchronized if there are already ten dishes on the table. All chefs
Just wait:
public synchronized void putFood(Food f){
while(() >= ){
try{
();
}catch(Exception e){}
}
(f);
notifyAll();
}
Get the dishes: same as above, if there is no dish on the table, all diners have to wait:
public synchronized Food getFood(){
while(() <= 0){
try{
();
}catch(Exception e){}
}
Food f = (Food)();
notifyAll();
return f;
}
Chef category:
Since multiple chefs have to put dishes on a table, the table they want to operate should be the same object. We construct
In the method, the table object is passed in so as to control the generation of only one table in the main thread.
When a chef needs to cook, I use sleep in the make method to indicate that he needs to consume and when, using a random number of 200 plus 200
The certificate time is between 200-400ms. After it is done, it must be placed on the table.
There is a very important question here that must be paid attention to, which is the issue of what range synchronization, because the competition is the table, so
Some putFood is synchronized, but we cannot also put the time when the chef cooks his own dishes in synchronization, because each cooks them. Similarly, diners
When eating dishes, we should not be synchronized. Only when picking dishes from the table is competitive, and when eating them, we should eat them separately.
So the code for the chef class is as follows:
class Chef extends Thread{
Table t;
Random r = new Random(12345);
public Chef(Table t){
= t;
}
public void run(){
while(true){
Food f = make();
(f);
}
}
private Food make(){
try{
(200+(200));
}catch(Exception e){}
return new Food();
}
}
Similarly, the codes for our generation of diners are as follows:
class Eater extends Thread{
Table t;
Random r = new Random(54321);
public Eater(Table t){
= t;
}
public void run(){
while(true){
Food f = ();
eat(f);
}
}
private void eat(Food f){
try{
(400+(200));
}catch(Exception e){}
}
}
The complete program is here:
package debug;
import .*;
import .*;
class Food{}
class Table extends LinkedList{
int maxSize;
public Table(int maxSize){
= maxSize;
}
public synchronized void putFood(Food f){
while(() >= ){
try{
();
}catch(Exception e){}
}
(f);
notifyAll();
}
public synchronized Food getFood(){
while(() <= 0){
try{
();
}catch(Exception e){}
}
Food f = (Food)();
notifyAll();
return f;
}
}
class Chef extends Thread{
Table t;
String name;
Random r = new Random(12345);
public Chef(String name,Table t){
= t;
= name;
}
public void run(){
while(true){
Food f = make();
(name+" put a Food:"+f);
(f);
}
}
private Food make(){
try{
(200+(200));
}catch(Exception e){}
return new Food();
}
}
class Eater extends Thread{
Table t;
String name;
Random r = new Random(54321);
public Eater(String name,Table t){
= t;
= name;
}
public void run(){
while(true){
Food f = ();
(name+" get a Food:"+f);
eat(f);
}
}
private void eat(Food f){
try{
(400+(200));
}catch(Exception e){}
}
}
public class Test {
public static void main(String[] args) throws Exception{
Table t = new Table(10);
new Chef("Chef1",t).start();
new Chef("Chef2",t).start();
new Chef("Chef3",t).start();
new Chef("Chef4",t).start();
new Eater("Eater1",t).start();
new Eater("Eater2",t).start();
new Eater("Eater3",t).start();
new Eater("Eater4",t).start();
new Eater("Eater5",t).start();
new Eater("Eater6",t).start();
}
}
In this example, we mainly focus on the following aspects:
1. The object to be protected by the synchronization method, in this case, the table cannot be placed on top or picked up at the same time.
If we implement the putFood method and getFood method in the chef class and diner class, then we should do this:
(Taking putFood as an example)
class Chef extends Thread{
Table t;
String name;
public Chef(String name,Table t){
= t;
= name;
}
public void run(){
while(true){
Food f = make();
(name+" put a Food:"+f);
putFood(f);
}
}
private Food make(){
Random r = new Random(200);
try{
(200+());
}catch(Exception e){}
return new Food();
}
public void putFood(Food f){//The method itself cannot be synchronized because it synchronizes this., that is, an instance of Chef
synchronized(t) {//What you want to protect is t
while (() >= ) {
try {
();
}
catch (Exception e) {}
}
(f);
();
}
}
}
2. The synchronization range is in this case, two methods of putting and picking, and it is not possible to make cooking and eating irrelevant tasks.
Placed in protected areas.
3. Participant to volume ratio.
The relationship between the proportion of producers and consumers, and the number of dishes that can be placed on the table
It is an important factor affecting performance. If too many producers are waiting, they need to increase consumers or reduce producer data. Otherwise
This increases the number of producers or reduces the number of consumers.
In addition, if the table has sufficient capacity, it can greatly improve performance, in this case, the producer and
The number of consumers, but when the capacity is large enough, you often need to have enough physical memory.
Before entering the practical chapter, let’s briefly talk about the general principles of multi-threaded programming.
[Security] is the primary principle of multi-threaded programming. If more than two threads access the same object, one thread will be damaged
The data of another thread violates the principle of security, and such programs cannot enter practical applications.
Security guarantees can be controlled manually by designing secure classes and programmers. If multiple threads access the same object,
It will endanger security. Such classes are thread-safe classes. In JAVA, for example, the String class is designed as a thread-safe class.
If it is not a thread-safe class, then programmers need to manually control its security when accessing instances of these classes.
[Feasibility] is another important principle of multi-threaded programming. If only security is achieved, the program cannot be continued at a certain point.
If continuous execution or multiple threads die locked, such programs cannot be applied as real multi-threaded programs.
Relatively speaking, security and feasibility are mutually incompatible. The higher the security program, the lower the liability guild will be. Comprehensive balance is required.
[High performance] The purpose of multi-threading is to increase the performance of program operation. If a multi-threading work is not completed yet
If a single thread completes quickly, then don’t apply multi-threading.
High-performance programs mainly have the following factors:
Data throughput, processing capability that can be completed within a certain period of time.
Response speed, the time from the time the request is issued to the time when the response is received.
Capacity refers to the number of tasks that are handled at the same time.
Security and feasibility are necessary conditions. If these two principles are not met, it cannot be called a true multi-threaded program.
Highness is the purpose of multi-threaded programming, and it can also be said to be a sufficient and necessary condition. Otherwise, why use multi-threaded programming?
[Producer and Consumer Model]
First, we will enter the first section of the practical chapter with a producer and consumer model.
Who is protected in the producer and consumer model?
Multithreaded programming is protecting certain objects, which are "hungry resources" and must be used to the maximum extent, which is also
Reason for adopting a multi-threaded approach. In the producer-consumer model, what we want to protect is the "repository". In my example below,
It's a table (table)
The model in my example is completely the producer-consumer model, but I changed my name. Chef-die model, this food
There is only 1 table in the hall, and up to 10 plates are placed at the same time. Now there are 4 chefs cooking. Every time a plate is prepared, they are placed on the table (the producer will
The products are placed in the warehouse), and 6 diners keep eating (consumers consume products, and to illustrate the problem, their appetite is unlimited).
Generally speaking, the chef makes a dish at 200-400ms, while the diners have to finish a dish at 400-600ms. When the table is filled with 10
After a plate, all the chefs could no longer put it on the table, and when the table had no plates, all the diners had to wait.
Let’s design this program below:
Because we don’t know what kind of dish it is, we call it food:
class Food{}
Then there is the table, because it must be placed in an orderly manner and taken in an orderly manner (two diners cannot compete for the third dish at the same time), so we
Extending LinkedList, or you can use a LinkedList as a property to achieve the same goal. In the example, I use it
Inheritance, pass in a maximum value that can be placed from the constructor method
class Table extends {
int maxSize;
public Table(int maxSize){
= maxSize;
}
}
Now we need to add two methods to it, one is the method of the chef putting the dishes on it, and the other is the method of the diner picking the dishes from the table.
Putting dishes: Because multiple chefs put dishes on a table, the chef's put dishes must be synchronized if there are already ten dishes on the table. All chefs
Just wait:
public synchronized void putFood(Food f){
while(() >= ){
try{
();
}catch(Exception e){}
}
(f);
notifyAll();
}
Get the dishes: same as above, if there is no dish on the table, all diners have to wait:
public synchronized Food getFood(){
while(() <= 0){
try{
();
}catch(Exception e){}
}
Food f = (Food)();
notifyAll();
return f;
}
Chef category:
Since multiple chefs have to put dishes on a table, the table they want to operate should be the same object. We construct
In the method, the table object is passed in so as to control the generation of only one table in the main thread.
When a chef needs to cook, I use sleep in the make method to indicate that he needs to consume and when, using a random number of 200 plus 200
The certificate time is between 200-400ms. After it is done, it must be placed on the table.
There is a very important question here that must be paid attention to, which is the issue of what range synchronization, because the competition is the table, so
Some putFood is synchronized, but we cannot also put the time when the chef cooks his own dishes in synchronization, because each cooks them. Similarly, diners
When eating dishes, we should not be synchronized. Only when picking dishes from the table is competitive, and when eating them, we should eat them separately.
So the code for the chef class is as follows:
class Chef extends Thread{
Table t;
Random r = new Random(12345);
public Chef(Table t){
= t;
}
public void run(){
while(true){
Food f = make();
(f);
}
}
private Food make(){
try{
(200+(200));
}catch(Exception e){}
return new Food();
}
}
Similarly, the codes for our generation of diners are as follows:
class Eater extends Thread{
Table t;
Random r = new Random(54321);
public Eater(Table t){
= t;
}
public void run(){
while(true){
Food f = ();
eat(f);
}
}
private void eat(Food f){
try{
(400+(200));
}catch(Exception e){}
}
}
The complete program is here:
package debug;
import .*;
import .*;
class Food{}
class Table extends LinkedList{
int maxSize;
public Table(int maxSize){
= maxSize;
}
public synchronized void putFood(Food f){
while(() >= ){
try{
();
}catch(Exception e){}
}
(f);
notifyAll();
}
public synchronized Food getFood(){
while(() <= 0){
try{
();
}catch(Exception e){}
}
Food f = (Food)();
notifyAll();
return f;
}
}
class Chef extends Thread{
Table t;
String name;
Random r = new Random(12345);
public Chef(String name,Table t){
= t;
= name;
}
public void run(){
while(true){
Food f = make();
(name+" put a Food:"+f);
(f);
}
}
private Food make(){
try{
(200+(200));
}catch(Exception e){}
return new Food();
}
}
class Eater extends Thread{
Table t;
String name;
Random r = new Random(54321);
public Eater(String name,Table t){
= t;
= name;
}
public void run(){
while(true){
Food f = ();
(name+" get a Food:"+f);
eat(f);
}
}
private void eat(Food f){
try{
(400+(200));
}catch(Exception e){}
}
}
public class Test {
public static void main(String[] args) throws Exception{
Table t = new Table(10);
new Chef("Chef1",t).start();
new Chef("Chef2",t).start();
new Chef("Chef3",t).start();
new Chef("Chef4",t).start();
new Eater("Eater1",t).start();
new Eater("Eater2",t).start();
new Eater("Eater3",t).start();
new Eater("Eater4",t).start();
new Eater("Eater5",t).start();
new Eater("Eater6",t).start();
}
}
In this example, we mainly focus on the following aspects:
1. The object to be protected by the synchronization method, in this case, the table cannot be placed on top or picked up at the same time.
If we implement the putFood method and getFood method in the chef class and diner class, then we should do this:
(Taking putFood as an example)
class Chef extends Thread{
Table t;
String name;
public Chef(String name,Table t){
= t;
= name;
}
public void run(){
while(true){
Food f = make();
(name+" put a Food:"+f);
putFood(f);
}
}
private Food make(){
Random r = new Random(200);
try{
(200+());
}catch(Exception e){}
return new Food();
}
public void putFood(Food f){//The method itself cannot be synchronized because it synchronizes this., that is, an instance of Chef
synchronized(t) {//What you want to protect is t
while (() >= ) {
try {
();
}
catch (Exception e) {}
}
(f);
();
}
}
}
2. The synchronization range is in this case, two methods of putting and picking, and it is not possible to make cooking and eating irrelevant tasks.
Placed in protected areas.
3. Participant to volume ratio.
The relationship between the proportion of producers and consumers, and the number of dishes that can be placed on the table
It is an important factor affecting performance. If too many producers are waiting, they need to increase consumers or reduce producer data. Otherwise
This increases the number of producers or reduces the number of consumers.
In addition, if the table has sufficient capacity, it can greatly improve performance, in this case, the producer and
The number of consumers, but when the capacity is large enough, you often need to have enough physical memory.