Operating Systems Write a JAVA multi-threading program that aim to calculate the following formula:Seq - x'Result =y*a) Create a Thread class named Seq that aims to calculate the following sequence:Seq(N) = ++ +123N...N-1N-2b) Create a Thread class named POF that aims to calculate the power of givennumbers (x to the power y) c) Create a thread class named Worker that takes two positive integers, when itstarts running, it creates and runs THREE thread instances: One of type SEQ andtwo of type POF. When they finish, this thread prints the final result according tothe above formula.d) Create a main class that reads a number N from the user, then generates Nrandom numbers between 0 and 12 and saves them in an array ARR. Then, itcalculates the result of each two consecutive numbers in the array using the classWorker.Ex:з |9 117The program must print: Result(7,3), Result(3,9), Result(9,11)

As per our guidelines, only the first question is answerable in case provided with multiple…

Write a JAVA multi-threading program that aim to calculate the following formula: Seq – x" Result = a) Create a Thread class named Seq that aims to calculate the following sequence: 3 + .…+ N-2 N Seq(N) = +2 ... N-1

Write a JAVA multi-threading program that aim to calculate the following formula: Seq – x" Result = a) Create a Thread class named Seq that aims to calculate the following sequence: 3 + .…+ N-2 N Seq(N) = +2 ... N-1

Systems Architecture

7th Edition

ISBN:9781305080195

Author:Stephen D. Burd

Publisher:Stephen D. Burd

Chapter11: Operating Systems

Section: Chapter Questions

Problem 14VE

See similar textbooks

Similar questions

1. Suppose you are a student of East West University. You have to design a multithreadedsystem in java for your CSE110 course. So, you are assigned a job with followingdescriptions. You have to design a class NumberComputator which has a functionprintComposite(int n) that can take a parameter N and print the composite numberfrom 1 to nth term. Composite numbers are the number that are not prime number.Again, create two thread class (ThreadOne, ThreadTwo) by extending the Threadclass so that all of the thread should call the method “printComposite(int n)” of theNumberComputator class. Again, write a main java class named“MultiProgrammingDemo” with a main method that instantiate two objects of twothreads(ThreadOne, ThreadTwo).Your task is to process and run two threads simultaneously in the main method byconsidering the fact that when one thread printing with the printComposite(n)function the other threads must be wait for the completion of the work the initial thread.Design a JAVA…
Write complete Java code to define a thread for printing all the Odd Nos from 1 to 5000 which are divisible by 9. Thread must sleep for 5 seconds. Implement the threading using the Runnable java provided Interface. Finally, create three different threads with names ThreadOne, ThreadTwo and ThreadThree in main(). Execute the code in the file where threading is implemented. Apply the Java multithreading exception handling mechanism properly
Write program for the following Create a child thread class for sorting an array of 10000 size string values Create a child class for calculating factorial of 50 Create a child thread class for calculating base b to the power p Create a single object of each thread in the main thread, and stop the execution of main thread until the termination of all child threads using join method
Multi-threading A) Write a Thread class (called worker) that takes two numbers (A and B, A < B) and calculates the products of all numbers between A and B. the result is stored in a local variable than can be accessed through a get method. B) Write a main program to calculate the factorial of a given number n (). The main thread reads n from the user, then creates two instances of Worker. Each one is requested to calculate the half of numbers between 1 and n. Once they finish, the main thread will gather their results and print the final result (result1 x result2). Example when n=10
No screenshot needed, just explain the program and answer the red question to copy program /* Multi-threaded example */ #include <stdio.h> #include <stdlib.h> #include <pthread.h> #define NUM_THREADS 10 /*This data is shared by the thread(s) */ pthread_t tid[NUM_THREADS]; /*This is the thread function */ void *runner(void *param); int main(int argc, char *argv[]) { int i; pthread_attr_t attr; printf("I am the parent thread\n"); /* get the default attributes */ pthread_attr_init(&attr); /* set the scheduling algorithm to PROCESS(PCS) or SYSTEM(SCS) */ pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); /* set the scheduling policy - FIFO, RR, or OTHER */ pthread_attr_setschedpolicy(&attr, SCHED_OTHER); /* create the threads */ for (i = 0; i < NUM_THREADS; i++) pthread_create(&tid[i], &attr, runner, (void *) i); /* now join on each thread */ for (i = 0; i < NUM_THREADS; i++) pthread_join(tid[i], NULL); printf("I am the parent thread…
Part 1: Thread creation (30%)a. Using Java multithreading library, write a Java program that calculates the sum of the numbersfrom 1 to 100,000,000. Split the numbers between four threads equally where each threadcalculates the sum of one fourth of the numbers. For example, the 1st thread will calculate the sumof the numbers from 1 to 25,000,000 whereas the 2nd thread will calculate the sum of the numbersfrom 25,000,001 to 50,000,000 and so forth. The main thread will have to print out the sum aftergathering the results. Note that you have the choice to create threads by either implementingRunnable interface or extending Thread class.b. Now, write a sequential version of the program described above using a single main thread (i.e.,without multithreading). Make sure to record and print out the time spent during the execution ofboth sequential and multithreaded versions (hint: you may consider usingSystem.currentTimeMillis() to record execution time).Part 2: Synchronization (40%)Assume…
calculate the number of memory bytes accessed by this program: void my_dgemv(int n, double* A, double* x, double* y) { #pragma omp parallel { int nthreads = omp_get_num_threads(); int thread_id = omp_get_thread_num(); printf("Hello world: thread %d of %d checking in. \n", thread_id, nthreads); } // insert your dgemv code here. you may need to create additional parallel regions, // and you may want to comment out the above parallel code block that prints out // nthreads and thread_id so as to not taint your timings #pragma omp parallel for // insert your code here: implementation of basic matrix multiply for(int i = 0; i < n; i++) { #pragma omp parallel for for(int j = 0; j < n; j++) { y[i] += A[i * n + j] * x[j]; } } }
USE PYTHON MULTI THREADING TO COMPLETE DO NOT USE PROCESSES ONLY COMPLETE PART 2 using MULTI THREADING 1) Basic version with two levels of threads (master and slaves) One master thread aggregates and sums the result of n slave-threads where each slavethread sums a different range of values in an array of 1000 random integers (please program to generate 1000 random integers to populate the array). ************ONLY COMPLETE THIS PART BELOW*************** 2) Advanced version with more than two levels of threadsThe master thread creates two slave-threads where each slave-thread is responsible to sum half segment of the array. Each slave thread will fork/spawn two new slave-threads where each new slave-threadsums half of the array segment received by its parent. Each slave thread will return the subtotal to its parent thread and the parent thread aggregates and returns the total to its parent thread. Start with 7 nodes thread tree, when you are comfortable, you can extend it to a full…
Write a multi thread C++ code that adds an array of 1000 numbers. This program will be passed a number on the command line and then create threads accordingly. The array should be evenly distributed according to the number of threads. Each thread calculates its sum and then the main thread displays the final sum.
Modify this threading example to use, exclusively, multiprocessing, instead of threading. import threadingimport time class BankAccount(): def __init__(self, name, balance): self.name = name self.balance = balance def __str__(self): return self.name # These accounts are our shared resourcesaccount1 = BankAccount("account1", 100)account2 = BankAccount("account2", 0) class BankTransferThread(threading.Thread): def __init__(self, sender, receiver, amount): threading.Thread.__init__(self) self.sender = sender self.receiver = receiver self.amount = amount def run(self): sender_initial_balance = self.sender.balance sender_initial_balance -= self.amount # Inserting delay to allow switch between threads time.sleep(0.001) self.sender.balance = sender_initial_balance receiver_initial_balance = self.receiver.balance receiver_initial_balance += self.amount # Inserting delay to allow switch between threads time.sleep(0.001)…
Write a multithreaded Hello World program using OpenMP. Have each thread say “Hello world” along with its thread ID and the number of threads the program is using.Run the program with as many threads as your computer will allow. Then try setting the thread count to a different number. please post:- The source code.- A screenshot of the program running.- A screenshot of the program running with a different thread count.
In Python code: Modify this threading example to use, exclusively, multiprocessing, instead of threading. import threadingimport time class BankAccount(): def __init__(self, name, balance): self.name = name self.balance = balance def __str__(self): return self.name # These accounts are our shared resourcesaccount1 = BankAccount("account1", 100)account2 = BankAccount("account2", 0) class BankTransferThread(threading.Thread): def __init__(self, sender, receiver, amount): threading.Thread.__init__(self) self.sender = sender self.receiver = receiver self.amount = amount def run(self): sender_initial_balance = self.sender.balance sender_initial_balance -= self.amount # Inserting delay to allow switch between threads time.sleep(0.001) self.sender.balance = sender_initial_balance receiver_initial_balance = self.receiver.balance receiver_initial_balance += self.amount # Inserting delay to allow switch between threads…