Чипак Егор 496 Threads+Miniorm+Reverser+Collections+EX

solutions/chipak/pom.xml

@@ -0,0 +1,40 @@
+<?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>chipak</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <name>chipak</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>
+    </dependency>
+    <dependency>
+      <groupId>org.twitter4j</groupId>
+      <artifactId>twitter4j-stream</artifactId>
+      <version>[4.0,)</version>
+    </dependency>
+    <dependency>
+      <groupId>com.beust</groupId>
+      <artifactId>jcommander</artifactId>
+      <version>1.48</version>
+    </dependency>
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+      <version>1.4.190</version>
+    </dependency>
+  </dependencies>
+</project>

solutions/chipak/src/main/java/ru/fizteh/fivt/students/chipak/Threads/BlockingQueue.java

@@ -0,0 +1,106 @@
+package ru.fizteh.fivt.students.chipak.Threads;
+
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class BlockingQueue<T> {
+
+    private Queue<T> queue;
+    private int maxSize;
+    private final Lock lock = new ReentrantLock();
+    private final Condition notEnoughSpace = lock.newCondition();
+    private final Condition notEnoughElements = lock.newCondition();
+    private final Object offerSynchronizer = new Object();
+    private final Object takeSynchronizer = new Object();
+
+    BlockingQueue(int size) {
+        queue = new ArrayDeque<T>();
+        maxSize = size;
+    }
+
+    void offer(List<T> toAdd) throws InterruptedException {
+        synchronized (offerSynchronizer) {
+            lock.lock();
+            try {
+                while ((queue.size() + toAdd.size()) > maxSize) {
+                    notEnoughSpace.await();
+                }
+                queue.addAll(toAdd);
+                notEnoughElements.signalAll();
+            } finally {
+                lock.unlock();
+            }
+        }
+    }
+
+    List<T> take(int n) throws InterruptedException {
+        synchronized (takeSynchronizer) {
+            lock.lock();
+            List<T> ans = new ArrayList<T>();
+            try {
+
+                while (queue.size() < n) {
+                    notEnoughElements.await();
+                }
+                for (int i = 0; i < n; ++i) {
+                    ans.add(queue.remove());
+                }
+                notEnoughElements.signalAll();
+            } finally {
+                lock.unlock();
+                return ans;
+            }
+        }
+    }
+
+    void offer(List<T> toAdd, long timeout) throws  InterruptedException {
+        synchronized (offerSynchronizer) {
+            lock.lock();
+            long waitingTime = timeout;
+            final long startTime = System.currentTimeMillis();
+            try {
+                while (queue.size() + toAdd.size() > maxSize && waitingTime > 0) {
+                    notEnoughElements.await(waitingTime, TimeUnit.MILLISECONDS);
+                    waitingTime = timeout - (System.currentTimeMillis() - startTime);
+                }
+                if (queue.size() + toAdd.size() <= maxSize) {
+                    queue.addAll(toAdd);
+                    notEnoughElements.notifyAll();
+                }
+            } finally {
+                lock.unlock();
+            }
+        }
+    }
+
+    List<T> take(int n, long timeout) throws InterruptedException {
+        synchronized (takeSynchronizer) {
+            lock.lock();
+            List<T> ans = new ArrayList<T>();
+            long waitingTime = timeout;
+            final long startTime = System.currentTimeMillis();
+            try {
+                while (queue.size() < n && waitingTime > 0) {
+                    notEnoughElements.await(waitingTime, TimeUnit.MILLISECONDS);
+                    waitingTime = timeout - (System.currentTimeMillis() - startTime);
+                }
+                if (queue.size() >= n) {
+                    for (int i = 0; i < n; ++i) {
+                        ans.add(queue.remove());
+                    }
+                    notEnoughElements.notifyAll();
+                }
+            } finally {
+                lock.unlock();
+                return ans;
+            }
+        }
+    }
+}

solutions/chipak/src/main/java/ru/fizteh/fivt/students/chipak/Threads/Counter.java

@@ -0,0 +1,54 @@
+package ru.fizteh.fivt.students.chipak.Threads;
+
+
+
+public class Counter {
+
+    private static volatile int currentID;
+
+    private static Object synchronizer = new Object();
+
+    private static class OneCounter implements Runnable {
+        private int id, size;
+
+
+        OneCounter(int id, int size) {
+            this.id = id;
+            this.size = size;
+        }
+
+        @Override
+        public void run() {
+            while (true) {
+                try {
+                    synchronized (synchronizer) {
+                        while (id != currentID) {
+                            synchronizer.wait();
+                        }
+                        System.out.println("Thread-" + String.valueOf(id));
+                        currentID++;
+                        if (currentID > size) {
+                            currentID %= size;
+                        }
+                        synchronizer.notifyAll();
+                    }
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) throws IllegalArgumentException {
+        if (args.length != 1) {
+            throw new IllegalArgumentException();
+        }
+        int n;
+        n = Integer.valueOf(args[0]);
+        currentID = 1;
+        for (int i = 0; i < n; i++) {
+            Thread oneCounter = new Thread(new OneCounter(i + 1, n));
+            oneCounter.start();
+        }
+    }
+}

solutions/chipak/src/main/java/ru/fizteh/fivt/students/chipak/collectionquery/Aggregates.java

@@ -0,0 +1,102 @@
+package ru.fizteh.fivt.students.chipak.collectionquery;
+
+import java.util.List;
+import java.util.function.Function;
+
+
+public class Aggregates {
+
+
+    public static <C, T extends Comparable<T>> Function<C, T> max(Function<C, T> expression) {
+        return new AggregationFunction<C, T>() {
+            private Function<C, T> converter = expression;
+
+            @Override
+            public T apply(List<C> list) {
+                T result = null;
+                for (C element : list) {
+                    if (result == null) {
+                        result = converter.apply(element);
+                    } else {
+                        T currentResult = converter.apply(element);
+                        if (currentResult.compareTo(result) > 0) {
+                            result = currentResult;
+                        }
+                    }
+                }
+                return result;
+            }
+
+            @Override
+            public T apply(C c) {
+                return null;
+            }
+        };
+    }
+
+
+    public static <C, T extends Comparable<T>> Function<C, T> min(Function<C, T> expression) {
+        return new AggregationFunction<C, T>() {
+            private Function<C, T> converter = expression;
+
+            @Override
+            public T apply(List<C> list) {
+                T result = null;
+                for (C element : list) {
+                    if (result == null) {
+                        result = converter.apply(element);
+                    } else {
+                        T currentResult = converter.apply(element);
+                        if (currentResult.compareTo(result) < 0) {
+                            result = currentResult;
+                        }
+                    }
+                }
+                return result;
+            }
+
+            @Override
+            public T apply(C c) {
+                return null;
+            }
+        };
+    }
+
+
+    public static <C> Function<C, Integer> count(Function<C, ?> expression) {
+        return new AggregationFunction<C, Integer>() {
+            @Override
+            public Integer apply(List<C> list) {
+                return list.size();
+            }
+
+            @Override
+            public Integer apply(C c) {
+                return null;
+            }
+        };
+    }
+
+
+    public static <C> Function<C, Double> avg(Function<C, ? extends Number> expression) {
+        return new AggregationFunction<C, Double>() {
+            private Function<C, ? extends Number> converter = expression;
+
+            @Override
+            public Double apply(List<C> list) {
+                Double result = 0d;
+                for (C element : list) {
+                    result += converter.apply(element).doubleValue();
+                }
+                result /= list.size();
+                return result;
+            }
+
+            @Override
+            public Double apply(C t) {
+                return null;
+            }
+        };
+    }
+
+}

solutions/chipak/src/main/java/ru/fizteh/fivt/students/chipak/collectionquery/AggregationFunction.java

@@ -0,0 +1,8 @@
+package ru.fizteh.fivt.students.chipak.collectionquery;
+
+import java.util.List;
+import java.util.function.Function;
+
+public interface AggregationFunction<T, E> extends Function<T, E> {
+    E apply(List<T> list);
+}