Максим Ермолаев, 494, Threads

ermolmak/pom.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>ru.fizteh.fivt.students</groupId>
+    <artifactId>parent</artifactId>
+    <version>1.0-SNAPSHOT</version>
+  </parent>
+  <groupId>ru.fizteh.fivt.students</groupId>
+  <artifactId>ermolmak</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <name>ermolmak</name>
+  <url>http://maven.apache.org</url>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>[3.8.1,)</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.beust</groupId>
+      <artifactId>jcommander</artifactId>
+      <version>1.48</version>
+    </dependency>
+    <dependency>
+      <groupId>org.twitter4j</groupId>
+      <artifactId>twitter4j-core</artifactId>
+      <version>4.0.4</version>
+    </dependency>
+    <dependency>
+      <groupId>org.twitter4j</groupId>
+      <artifactId>twitter4j-stream</artifactId>
+      <version>[4.0,)</version>
+    </dependency>
+  </dependencies>
+</project>

ermolmak/src/main/java/ru/fizteh/fivt/students/ermolmak/threads/blockingqueue/BlockingQueue.java

@@ -0,0 +1,36 @@
+package ru.fizteh.fivt.students.ermolmak.threads.blockingqueue;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class BlockingQueue<T> {
+    private final int maxSize;
+    private Queue<T> queue;
+
+    public BlockingQueue(int maxSize) {
+        this.maxSize = maxSize;
+        queue = new LinkedList<>();
+    }
+
+    public synchronized void offer(List<T> e) throws InterruptedException {
+        while (queue.size() + e.size() > maxSize) {
+            wait();
+        }
+        queue.addAll(e);
+        notifyAll();
+    }
+
+    public synchronized List<T> take(int n) throws InterruptedException {
+        while (queue.size() < n) {
+            wait();
+        }
+        List<T> result = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            result.add(queue.remove());
+        }
+        notifyAll();
+        return result;
+    }
+}

ermolmak/src/main/java/ru/fizteh/fivt/students/ermolmak/threads/call/Call.java

@@ -0,0 +1,24 @@
+package ru.fizteh.fivt.students.ermolmak.threads.call;
+
+public class Call {
+    public static void main(String[] args) {
+        if (args.length == 1) {
+            try {
+                int num = Integer.parseInt(args[0]);
+                if (num > 0) {
+                    (new Thread(new Caller(num))).start();
+                } else {
+                    printUsage();
+                }
+            } catch (NumberFormatException e) {
+                printUsage();
+            }
+        } else {
+            printUsage();
+        }
+    }
+
+    private static void printUsage() {
+        System.out.println("Usase: Call {number of threads}");
+    }
+}

ermolmak/src/main/java/ru/fizteh/fivt/students/ermolmak/threads/call/Caller.java

@@ -0,0 +1,108 @@
+package ru.fizteh.fivt.students.ermolmak.threads.call;
+
+class Caller implements Runnable {
+    private final int numberOfThreads;
+    private final boolean[] answers;
+    private final Object monitor;
+    private Turn turn;
+    private int unansweredThreads;
+    private int yesCounter;
+
+    Caller(int numberOfThreads) {
+        this.numberOfThreads = numberOfThreads;
+        answers = new boolean[numberOfThreads];
+        monitor = new Object();
+    }
+
+    private void reset() {
+        unansweredThreads = numberOfThreads;
+        yesCounter = 0;
+        for (int i = 0; i < numberOfThreads; ++i) {
+            answers[i] = false;
+        }
+    }
+
+    @Override
+    public void run() {
+        turn = Turn.MAIN_THREAD;
+        for (int i = 0; i < numberOfThreads; ++i) {
+            (new Thread(new ChildThread(i))).start();
+        }
+        reset();
+
+        while (yesCounter != numberOfThreads) {
+            synchronized (monitor) {
+                System.out.println("Are you ready?");
+                turn = Turn.CHILD_THREAD;
+                monitor.notifyAll();
+                while (turn == Turn.CHILD_THREAD) {
+                    try {
+                        monitor.wait();
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+
+                if (yesCounter != numberOfThreads) {
+                    reset();
+                }
+            }
+        }
+    }
+
+    private enum Turn {
+        MAIN_THREAD,
+        CHILD_THREAD
+    }
+
+    private class ChildThread implements Runnable {
+        private final int myNumber;
+
+        ChildThread(int myNumber) {
+            this.myNumber = myNumber;
+        }
+
+        private boolean getAnswer() {
+            return Math.random() < 0.9;
+        }
+
+        @Override
+        public void run() {
+            while (yesCounter != numberOfThreads) {
+                synchronized (monitor) {
+                    while (turn == Turn.MAIN_THREAD) {
+                        try {
+                            monitor.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+
+                    boolean answer = getAnswer();
+                    if (answer) {
+                        ++yesCounter;
+                        System.out.println("Yes");
+                    } else {
+                        System.out.println("No");
+                    }
+                    --unansweredThreads;
+                    answers[myNumber] = true;
+
+                    if (unansweredThreads == 0) {
+                        turn = Turn.MAIN_THREAD;
+                        monitor.notifyAll();
+                        continue;
+                    }
+
+                    while (answers[myNumber] & yesCounter != numberOfThreads) {
+                        try {
+                            monitor.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

ermolmak/src/main/java/ru/fizteh/fivt/students/ermolmak/threads/counter/Counter.java

@@ -0,0 +1,25 @@
+package ru.fizteh.fivt.students.ermolmak.threads.counter;
+
+
+public class Counter {
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            printUsage();
+        } else {
+            try {
+                int numberOfThreads = Integer.parseInt(args[0]);
+                if (numberOfThreads > 0) {
+                    new CounterLauncher(numberOfThreads);
+                } else {
+                    printUsage();
+                }
+            } catch (NumberFormatException e) {
+                printUsage();
+            }
+        }
+    }
+
+    static void printUsage() {
+        System.out.println("Usage: Counter {number of threads}");
+    }
+}

ermolmak/src/main/java/ru/fizteh/fivt/students/ermolmak/threads/counter/CounterLauncher.java

@@ -0,0 +1,50 @@
+package ru.fizteh.fivt.students.ermolmak.threads.counter;
+
+class CounterLauncher {
+    private int numberOfThreads;
+    private Integer currentThread;
+    private Object monitor;
+
+    CounterLauncher(int numberOfThreads) {
+        this.numberOfThreads = numberOfThreads;
+        this.currentThread = 0;
+        monitor = new Object();
+
+        for (int i = 0; i < numberOfThreads; ++i) {
+            (new Thread(new CounterThread(i))).start();
+        }
+    }
+
+    class CounterThread implements Runnable {
+        private int myNum;
+
+        CounterThread(int number) {
+            myNum = number;
+        }
+
+        @Override
+        public void run() {
+            while (true) {
+                synchronized (monitor) {
+                    while (currentThread != myNum) {
+                        try {
+                            monitor.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                    ++currentThread;
+                    System.out.println("Thread-" + currentThread);
+                    currentThread %= numberOfThreads;
+                    monitor.notifyAll();
+
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+}

ermolmak/src/main/java/ru/fizteh/fivt/students/ermolmak/twitterstream/Area.java

@@ -0,0 +1,29 @@
+package ru.fizteh.fivt.students.ermolmak.twitterstream;
+
+import twitter4j.GeoLocation;
+
+class Area {
+    private GeoLocation location;
+    private double radius;
+
+    Area(GeoLocation location, double radius) {
+        this.location = location;
+        this.radius = radius;
+    }
+
+    public GeoLocation getLocation() {
+        return location;
+    }
+
+    public void setLocation(GeoLocation location) {
+        this.location = location;
+    }
+
+    public double getRadius() {
+        return radius;
+    }
+
+    public void setRadius(double radius) {
+        this.radius = radius;
+    }
+}