daily pastebin goal
7%
SHARE
TWEET

Untitled

a guest Mar 13th, 2018 63 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. public class TwoThreads {
  2.     public static class Thread1 extends Thread {
  3.         public void run() {
  4.             System.out.println("A");
  5.             System.out.println("B");
  6.         }
  7.     }
  8.  
  9.     public static class Thread2 extends Thread {
  10.         public void run() {
  11.             System.out.println("1");
  12.             System.out.println("2");
  13.         }
  14.     }
  15.  
  16.     public static void main(String[] args) {
  17.        // new Thread1().start();
  18.        // new Thread2().start();
  19.         new Thread(new ThreadAB("A","B")).start();
  20.         new Thread(new ThreadAB("1", "2")).start();
  21.     }
  22.     public static class ThreadAB implements Runnable {
  23.  
  24.         protected String a,b;
  25.         public ThreadAB(String a, String b) {
  26.             this.a = a;
  27.             this.b = b;
  28.         }
  29.  
  30.         @Override
  31.         public void run() {
  32.             System.out.println(a);
  33.             System.out.println(b);
  34.         }
  35.  
  36.     }
  37.  
  38. }
  39. ====================
  40. zad 2
  41.  
  42. import java.util.Random;
  43. public class TenThreads {
  44.     private static class WorkerThread implements Runnable {
  45.         int max = Integer.MIN_VALUE;
  46.         int[] ourArray;
  47.  
  48.         public WorkerThread(int[] ourArray) {
  49.             this.ourArray = ourArray;
  50.         }
  51.  
  52.         // Find the maximum value in our particular piece of the array
  53.         public void run() {
  54.             for (int i = 0; i < ourArray.length; i++)
  55.                 max = Math.max(max, ourArray[i]);
  56.         }
  57.  
  58.         public int getMax() {
  59.             return max;
  60.         }
  61.     }
  62.  
  63.     public static void main(String[] args) {
  64.         WorkerThread[] threads = new WorkerThread[20];
  65.         Thread [] realThreads=new Thread[20];
  66.         int[][] bigMatrix = getBigHairyMatrix();
  67.         int max = Integer.MIN_VALUE;
  68.  
  69.         // Give each thread a slice of the matrix to work with
  70.         for (int i = 0; i < 20; i++) {
  71.             threads[i] = new WorkerThread(bigMatrix[i]);
  72.             realThreads[i]=new Thread(threads[i]);
  73.             realThreads[i].start();
  74.         }
  75.  
  76.         // Wait for each thread to finish
  77.         try {
  78.             for (int i = 0; i < 20; i++) {
  79.                 realThreads[i].join(); // why is this needed
  80.                 max = Math.max(max, threads[i].getMax());
  81.             }
  82.         } catch (InterruptedException e) {
  83.             // fall through
  84.         }
  85.  
  86.         System.out.println("Maximum value was " + max);
  87.     }
  88.  
  89.     static int[][] getBigHairyMatrix() {
  90.         int x = 100;
  91.         int y = 100;
  92.  
  93.         int[][] matrix = new int[x][y];
  94.         Random rnd = new Random();
  95.  
  96.         for (int i = 0; i < x; i++)
  97.             for (int j = 0; j < y; j++) {
  98.                 matrix[i][j] = rnd.nextInt();
  99.             }
  100.  
  101.         return matrix;
  102.     }
  103.  
  104. }
  105. ==================
  106. zad 3
  107.  
  108. import java.util.HashSet;
  109. import java.util.Scanner;
  110. import java.util.concurrent.Semaphore;
  111.  
  112. public class Naizmenicno {
  113.  
  114.     public static int NUM_RUNS = 1000;
  115.  
  116.     int f1count;
  117.     int f2count;
  118.     int maxDifference = 0;
  119.     int counter = 0;
  120.     Semaphore s1;
  121.     Semaphore s2;
  122.     Object lock = new Object();
  123.  
  124.  
  125.     /**
  126.      * Metod koj treba da gi inicijalizira vrednostite na semaforite i
  127.      * ostanatite promenlivi za sinhronizacija.
  128.      *
  129.      */
  130.     public void init(int count) {
  131.         //da se implementira
  132.         counter = count;
  133.         s1 = new Semaphore(count);
  134.         s2 = new Semaphore(0);
  135.     }
  136.  
  137.     class F1Thread extends Thread {
  138.  
  139.         public void executeF1() throws InterruptedException {
  140.             //da se implementira
  141.             s1.acquire();
  142.             //synchronized (lock) {
  143.                 f1();
  144.             //}
  145.             s2.release();
  146.         }
  147.  
  148.         @Override
  149.         public void run() {
  150.             try {
  151.                 executeF1();
  152.             } catch (Exception e) {
  153.                 e.printStackTrace();
  154.             }
  155.         }
  156.     }
  157.  
  158.     class F2Thread extends Thread {
  159.  
  160.         public void executeF2() throws InterruptedException {
  161.             //da se implementira
  162.             s2.acquire();
  163.             //synchronized (lock) {
  164.                 f2();
  165.             //}
  166.             s1.release();
  167.         }
  168.  
  169.         @Override
  170.         public void run() {
  171.             try {
  172.                 executeF2();
  173.             } catch (Exception e) {
  174.                 e.printStackTrace();
  175.             }
  176.         }
  177.     }
  178.  
  179.     public void f1() {
  180.         System.out.println("f1()");
  181.         f1count++;
  182.         if (f1count - f2count > maxDifference) {
  183.             maxDifference = f1count - f2count;
  184.         }
  185.     }
  186.  
  187.     public void f2() {
  188.         System.out.println("f2()");
  189.         f2count++;
  190.  
  191.         if (f1count - f2count > maxDifference) {
  192.             maxDifference = f1count - f2count;
  193.         }
  194.     }
  195.  
  196.     public static void main(String[] args) {
  197.         try {
  198.             Naizmenicno environment = new Naizmenicno();
  199.             environment.start();
  200.         } catch (Exception ex) {
  201.             ex.printStackTrace();
  202.         }
  203.     }
  204.  
  205.     public void start() throws Exception {
  206.  
  207.         System.out.println("Vnesete za kolku poveke sakate da se izvrsi f1()");
  208.         Scanner s = new Scanner(System.in);
  209.         int n = s.nextInt();
  210.         init(n);
  211.  
  212.         HashSet<Thread> threads = new HashSet<Thread>();
  213.         for (int i = 0; i < NUM_RUNS; i++) {
  214.             F1Thread f1 = new F1Thread();
  215.             F2Thread f2 = new F2Thread();
  216.             threads.add(f1);
  217.             threads.add(f2);
  218.         }
  219.  
  220.         for (Thread t : threads) {
  221.             t.start();
  222.         }
  223.  
  224.         for (Thread t : threads) {
  225.             t.join();
  226.         }
  227.         System.out.println("F1count: " + f1count);
  228.         System.out.println("F2count: " + f2count);
  229.         System.out.println("maxDifference: " + maxDifference);
  230.         System.out.println("Status: " + (maxDifference <= n));
  231.     }
  232. }
  233.  
  234. =====================
  235. zad 4
  236.  
  237. import java.util.HashSet;
  238. import java.util.Random;
  239. import java.util.Scanner;
  240. import java.util.concurrent.Semaphore;
  241.  
  242. public class CountThree {
  243.  
  244.     public static int NUM_RUNS=100;
  245.     /**
  246.      * Promenlivata koja treba da go sodrzi brojot na pojavuvanja na elementot 3
  247.      */
  248.     int count = 0;
  249.     /**
  250.      * TODO: definirajte gi potrebnite elementi za sinhronizacija
  251.      */
  252.     Object obj = new Object();
  253.  
  254.  
  255.     public void init() {
  256.  
  257.     }
  258.  
  259.     class Counter extends Thread {
  260.  
  261.         public void count(int[] data) throws InterruptedException {
  262.             //da se implementira
  263.             int pom = 0;
  264.             for (int i = 0; i < data.length;i++) {
  265.                 if(data[i]==3) {
  266.                     pom++;
  267.                 }
  268.             }
  269.             synchronized (obj) {
  270.                 count+=pom;
  271.             }
  272.         }
  273.  
  274.         private int[] data;
  275.  
  276.         public Counter(int[] data) {
  277.             this.data = data;
  278.         }
  279.         @Override
  280.         public void run(){
  281.             try{
  282.                 count(data);
  283.             }
  284.             catch (Exception e) {
  285.                 e.printStackTrace();
  286.             }
  287.         }
  288.     }
  289.  
  290.     public static void main(String[] args) {
  291.         try {
  292.             CountThree environment = new CountThree();
  293.             environment.start();
  294.         }
  295.         catch (Exception ex) {
  296.             ex.printStackTrace();
  297.         }
  298.     }
  299.  
  300.     public void start() throws Exception {
  301.         init();
  302.  
  303.         HashSet<Thread> threads = new HashSet<Thread>();
  304.         Scanner s = new Scanner(System.in);
  305.         int total = s.nextInt();
  306.  
  307.         for (int i = 0; i < NUM_RUNS; i++) {
  308.             int[] data = new int [total];
  309.             for (int j = 0; j< total; j++) {
  310.                 data[j] = s.nextInt();
  311.             }
  312.             Counter c = new Counter(data);
  313.             threads.add(c);
  314.         }
  315.         for (Thread t : threads) {
  316.             t.start();
  317.         }
  318.         for (Thread t : threads) {
  319.             t.join();
  320.         }
  321.         System.out.println(count);
  322.     }
  323.  
  324. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top