## The school teacher set up two small threading jobs

1. Design aTest.cpp, defines variables: unsigned int sum=0; creates two threads T1 and T2, T1 behavior: sum+=1; T2 behavior: sum+=2; when the sum is greater than 1000000, outputs the sum value and ends the program.

Q1: Run the program 10 times and record the results.

Q2:10 run results are consistent?If not, explain the reason.

Q3: Design anotherAutorun.cppIt canTest.exeRun N times (n=10000 or 100000...), automatically collect run results and save them inResult.txtFile.

Q4: Can we eliminateTest.exeInconsistency of results over multiple runs?Please give a solution and test its feasibility.

2. Design aQuadratic.cppFor solving N (n=10000 or 100000...)The coefficients a, b and c of the univariate quadratic equation are random integers, where a_0.takeQuadratic.cpp Multithreading2.cpp was modified to solve univariate quadratic equations with two threads.

Q1:Calculate separatelyQuadratic.cppRuntime with Multithreading2.cpp.

Q2: Calculate the Multithreading2.cpp acceleration ratio.

Q3: The difficulties in parallelizing serial algorithms are analyzed and summarized.

Q4: Retrieve the mainstream technologies, architectures and platforms that support parallel computing and describe their characteristics.

================================================================================

The teacher intended that it would be best to write in c, but at that time he had not sent out such detailed assignments.When I found my teacher's hair halfway through the writing, I had to put my scalp on it.

If available, c's code will be added.

================================================================================

The source code is as follows

================================================================================

Q1:

1. Create two threads, each implementing different functions.

package com.example.aosdemo.homework1; /** * Anonymous Thread Class * * @author _Yuan * @since 2020-6-15 18:40:15 */ public class Test { public static int sum=0; public void runAll(){ Thread thread1 = new Thread(){ public void run(){ while(sum<=1000000){ sum+=1;//Add 1 at a time } System.out.println("Thread1: sum="+sum); } }; //Thread 2 Thread thread2 = new Thread(){ public void run(){ while(sum<=1000000){ sum+=2;//Add 2 at a time } System.out.println("Thread2: sum="+sum); } }; thread1.start(); thread2.start(); } public static void main(String[] args) { Test test = new Test(); test.runAll(); } } }

Run result:

The results of each run are not exactly the same, sometimes the same, sometimes different.And the execution order is different.

Reason:

When the same data is accessed between multiple threads, the threads are in a competitive state, and whoever gets it first runs one time slice, and then grabs it the next time slice, so the result is not unique.

2. Execute the above procedure N times and save the execution result in txt.

package com.example.aosdemo.homework1; import java.io.FileNotFoundException; import java.io.PrintStream; /** * Anonymous Thread Class * * @author _Yuan * @since 2020-6-16 16:31:21 */ public class Autorun { public static final int NUM = 10000; public void wite() { try { PrintStream ps = new PrintStream("e:/result.txt"); // Creates a printout stream whose output goal is:Result.txtfile System.setOut(ps);//Assign the created printout stream to the system.That is, the next time the system outputs to ps //Loop Execution for (int i = 0; i <NUM ; i++) { Test test = new Test(); test.runAll(); } } catch (FileNotFoundException e) { e.printStackTrace(); } finally { System.out.close(); } }

Run result:

The results are unstable and some of the results are inconsistent.

3. To solve the above problem, I use a thread pool to perform all tasks serially.That is, to ensure that all tasks are executed in the order in which they are submitted.

package com.example.aosdemo.homework1; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * Thread pool SingleThreadExecutor causes thread sequential execution * * @author _Yuan * @since 2020-6-16 21:42:35 */ public class ThreadPoolTest { public static int sum = 0; static ExecutorService executorService = Executors.newSingleThreadExecutor(); public static void main(String[] args) { final Thread thread1 = new Thread(new Runnable() { @Override public void run() { while (sum <= 1000000) { sum += 1;//Add 1 at a time } System.out.println("Thread1: sum=" + sum); } } ); final Thread thread2 = new Thread(new Runnable() { @Override public void run() { while (sum <= 1000000) { sum += 2;//Add 2 at a time } System.out.println("Thread2: sum=" + sum); } } ); executorService.submit(thread1);//Thread pool commit executorService.submit(thread2); executorService.shutdown();//Close thread pool, reject task } }

Run result:

The execution results are consistently 1000001, and the execution order is always Thread1, Thread2.

note:

I don't know a solution, so take a look at this article----. Eight ways to make threads execute sequentially

================================================================================

Q2:

1. Write a loop to solve n univariate quadratic equations and add code to calculate run time.Encapsulated in the same thread class.

package com.example.aosdemo.homework2; import java.util.Random; /** * Thread class: calculates NUM univariate quadratic equations * *note: It is normal to have decimals in the results. If you want more accurate results, you can use BIgDecimal (for addition, subtraction, multiplication and division of the double type). * @author _Yuan * @since 2020-6-14 18:32:13 */ public class Mythread implements Runnable { public static final int NUM = 10001;//Number of equations public static int count1;//count public static int count2; @Override public void run() { long startTime = System.currentTimeMillis(); //Get Start Time Random random = new Random(100);//The random numbers generated by the same number of times are the same, so it must be written outside the for loop that NUM=100010 is the seed and NUM=10000 when 100 is the seed. for (int i = 1; i < NUM; i++) { // try { // Thread.sleep(1); //Sleep 2ms, modified to a certain value, allows multiple threads to work together when processing tasks account for a more even proportion // } catch (InterruptedException e) { // e.printStackTrace(); // } task(i, random); } long endTime = System.currentTimeMillis(); //Get End Time System.out.println("The total time spent in the program is:" + (endTime - startTime) + "ms"); //Output Program Runtime //Determine if it's single-threaded or multi-threaded if ("singleThread".equals(Thread.currentThread().getName())) { System.out.println("singleThread Number of processing tasks:" + (count1 + count2)); } else { System.out.println("multiThread1 Number of processing tasks:" + count1 + " multiThread2 Number of processing tasks:" + count2); } } //Calculating Quadratic Univariate Equation public void task(int i, Random random) { // Solution: x1,x2 random parameters: a,b,c criteria:t int a = random.nextInt(100);//Returns a random number greater than or equal to 0 and less than 100 int b = random.nextInt(100); int c = random.nextInt(100); double x1, x2, t; t = b * b - 4 * a * c;//Determine if there are solution conditions if (a != 0) { if (t < 0) { System.out.println("equation set" + i + ": " + a + "X*X+" + b + "X+" + c + " unsolvable " + " By " + Thread.currentThread().getName()); count1++; } else { x1 = ((-b) + Math.pow(t, 1 / 2)) / (2 * a); x2 = ((-b) - Math.pow(t, 1 / 2)) / (2 * a); System.out.println("equation set" + i + ": " + a + "X*X+" + b + "X+" + c + " Solve as-->X1=" + x1 + "," + "X2=" + x2 + " " + " By " + Thread.currentThread().getName()); count2++; } } } }

2. Create a single thread and execute the run method.

package com.example.aosdemo.homework2; /** * Comparison: Single-threaded quadratic equation * @author _Yuan * @since 2020-6-15 00:45:05 */ public class Quadratic { public static void main(String[] args) { //Single Thread Mythread singleThread = new Mythread(); new Thread(singleThread,"singleThread").start(); } }

Execution results:

3. Create a thread class object, which is used by both threads, and run the run method to achieve a coordinated solution for the threads.

package com.example.aosdemo.homework2; /** * Comparison: Multithreaded co-computing of quadratic equation of one variable * note: Since the equation parameters for each execution are generated by random numbers, all unavoidable calculations differ from one another, sometimes with a single thread taking less time * @author _Yuan * @since 2020-6-15 00:45:05 */ public class Multithreading2 { public static void main(String[] args) { //Collaborative multithreading Mythread multiThread = new Mythread(); new Thread(multiThread,"multiThread1").start(); new Thread(multiThread,"multiThread2").start(); } }

Execution results: