diff --git a/DataBaseService.java b/DataBaseService.java
new file mode 100644
index 0000000..cec3d21
--- /dev/null
+++ b/DataBaseService.java
@@ -0,0 +1,215 @@
+
+import com.google.common.base.CaseFormat;
+import com.tngtech.java.junit.dataprovider.internal.DataConverter;
+import ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations.Column;
+import ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations.PrimaryKey;
+import ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations.Table;
+
+import javax.management.OperationsException;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Field;
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DataBaseService <T,K>{
+    private Connection connection = null;
+    private Statement statement = null;
+    private ResultSet resultSet = null;
+    private Field primaryKey = null;
+    private List<AnnotatedField> columns = null;
+    private Class<T> typeClass = null;
+    private String tableName = "";
+    int primaryKeyIndex = -1;
+
+    private boolean hasTableYet = false;
+
+    private void connect() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {
+        Class.forName("org.h2.Driver").newInstance();
+        connection = DriverManager.getConnection("jdbc:h2:test",
+                "sa", "");
+        statement = connection.createStatement();
+    }
+
+    protected void finalize ( ) throws SQLException {
+        resultSet.close();
+        statement.close();
+        connection.close();
+    }
+
+    DataBaseService(Class<T> elementClass) throws ClassNotFoundException, SQLException, InstantiationException, IllegalAccessException {
+        try{
+            this.connect();
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+        columns = new ArrayList<>();
+        typeClass = elementClass;
+        Table table = typeClass.getAnnotation(Table.class);
+        if (table == null) {
+            throw new IllegalArgumentException("Class should be annotated with Table");
+        }
+        tableName = table.name();
+        if (tableName.equals("")) {
+            tableName = "MY_TABLE";
+        }
+        int i = 0;
+        for (Field elem : typeClass.getDeclaredFields()) {
+            if (elem.getAnnotation(Column.class) != null) {
+                columns.add(new AnnotatedField(elem));
+            }
+            if (elem.getAnnotation(PrimaryKey.class) != null) {
+                if (elem.getAnnotation(Column.class) == null) {
+                    throw new IllegalArgumentException("Первичный ключ должен иметь тип столбца");
+                }
+                if (primaryKey != null) {
+                    throw new IllegalArgumentException("Первичный ключ долден быть один");
+                }
+                primaryKey = elem;
+                primaryKeyIndex = i;
+            }
+            ++i;
+        }
+        try{
+            resultSet = connection.getMetaData().getTables(null, null,
+                            CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_UNDERSCORE, tableName), null);
+            if (resultSet.next()) {
+                hasTableYet = true;
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+
+    }
+
+
+
+    public T queryById(K id) throws OperationsException, SQLException, IllegalAccessException, InstantiationException {
+        if (!hasTableYet){
+            throw new OperationsException("Для данного запроа необходимо создать таблицу");
+        }
+        if (primaryKey == null){
+            throw new OperationsException("Должен суущестовать первичный ключ");
+        }
+        if (!id.getClass().isInstance(primaryKey.getType())){
+            throw new IllegalArgumentException("Ключ должен иметь тот же тип, что и первичные ключи таблицы");
+        }
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("SELECT * FROM ").append(tableName).append(" WERE ")
+                .append(columns.get(primaryKeyIndex).getColumnName()).append(" = ").append(id.toString());
+        resultSet = statement.executeQuery(newRequest.toString());
+        List<T> list = new ArrayList<>();
+        while (resultSet.next()) {
+            T item = typeClass.newInstance();
+            for (AnnotatedField field: columns) {
+                if (field.getElement().getType().equals(Integer.class)) {
+                    field.getElement().set(item, resultSet.getInt(field.getColumnName()));
+                }
+                if (field.getElement().getType().equals(String.class)) {
+                    field.getElement().set(item, resultSet.getString(field.getColumnName()));
+                }
+            }
+            list.add(item);
+        }
+        if (list.size() == 0) {
+            return null;
+        }
+        if (list.size() > 1) {
+            throw new OperationsException("Ошибка получения результата");
+        }
+        return list.get(0);
+    }
+
+    List<T> queryForAll() throws OperationsException, SQLException, IllegalAccessException, InstantiationException {
+
+        if (!hasTableYet){
+            throw new OperationsException("Для данного запроа необходимо создать таблицу");
+        }
+        if (primaryKey == null){
+            throw new OperationsException("Должен суущестовать первичный ключ");
+        }
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("SELECT * FROM ").append(tableName);
+        resultSet = statement.executeQuery(newRequest.toString());
+        List<T> list = new ArrayList<>();
+        while (resultSet.next()) {
+            T item = typeClass.newInstance();
+            for (AnnotatedField field: columns) {
+                if (field.getElement().getType().equals(Integer.class)) {
+                    field.getElement().set(item, resultSet.getInt(field.getColumnName()));
+                }
+                if (field.getElement().getType().equals(String.class)) {
+                    field.getElement().set(item, resultSet.getString(field.getColumnName()));
+                }
+            }
+            list.add(item);
+        }
+        return list;
+    }
+
+    void insert(T key) throws SQLException {
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("INSERT INTO").append(tableName).append(" (");
+        boolean first = true;
+        for (AnnotatedField field:columns){
+            if (!first){
+                newRequest.append(", ");
+            }else {
+                first = false;
+            }
+            newRequest.append(field.getColumnName());
+        }
+        statement.execute(newRequest.toString());
+
+    }
+
+    void update(T key) throws SQLException {
+        StringBuilder newRequest = new StringBuilder().append("UPDATE ").append(tableName).append(" SET ");
+        for (int i = 0; i < columns.size(); ++i) {
+            if (i != 0) {
+                newRequest.append(", ");
+            }
+            newRequest.append(columns.get(i).getColumnName()).append(" = ?");
+        }
+        newRequest.append(" WHERE ").append(columns.get(primaryKeyIndex).getColumnName())
+                .append(" = ?");
+        statement.execute(newRequest.toString());
+    }
+
+
+    void delete(T key) throws SQLException {
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("DELETE FROM ").append(tableName).append(columns.get(primaryKeyIndex).getColumnName()).append(" = ").append(key.toString());
+        statement.execute(newRequest.toString());
+    }
+
+    void createTable() throws OperationsException, SQLException {
+        if (hasTableYet) {
+            throw new OperationsException("Невозможно повторно создать таблицу");
+        }
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("CREATE TABLE ").append(tableName).append(" (");
+        int i = 0;
+        for (AnnotatedField field : columns) {
+            newRequest.append(field.getColumnName()).append(" ");
+            newRequest.append(field.getH2Type()).append(" ");
+            if (field.getElement().isAnnotationPresent(PrimaryKey.class)) {
+                newRequest.append("NOT NULL PRIMARY KEY ");
+                primaryKeyIndex = i;
+            }
+            i++;
+            newRequest.append(" , ");
+        }
+        newRequest.append(") ");
+        statement.execute(newRequest.toString());
+    }
+
+    void dropTable(){
+        try {
+            statement.execute("DROP TABLE " + tableName);
+            hasTableYet = false;
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/solutions/krakhmalev/1 b/solutions/krakhmalev/1
new file mode 100644
index 0000000..d00491f
--- /dev/null
+++ b/solutions/krakhmalev/1
@@ -0,0 +1 @@
+1
diff --git a/solutions/krakhmalev/AnnotatedField.java b/solutions/krakhmalev/AnnotatedField.java
new file mode 100644
index 0000000..7f2b5f6
--- /dev/null
+++ b/solutions/krakhmalev/AnnotatedField.java
@@ -0,0 +1,63 @@
+package ru.fizteh.fivt.students.krakhmalev.MiniORM;
+
+import com.google.common.base.CaseFormat;
+import com.sun.xml.internal.bind.v2.schemagen.xmlschema.Annotated;
+import ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations.Column;
+
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class AnnotatedField {
+    private String columnName;
+    private Field element;
+
+    private static final Map<Class, String> H2MAP;
+
+    public AnnotatedField(Field elem ) {
+        element = elem;
+        Column column = elem.getAnnotation(Column.class);
+        columnName = column.name();
+        if (columnName.equals("")) {
+            columnName = element.getName();
+            columnName = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, columnName);
+        }
+    }
+
+    public String getColumnName(){
+        return columnName;
+    }
+
+    public Field getElement() {
+        return element;
+    }
+
+    public String getH2Type(){
+        if (H2MAP.get(element.getType()) == null){
+            throw new IllegalArgumentException(columnName + " недопустимый тип для базы данных");
+        }
+        return H2MAP.get(element.getType());
+    }
+
+    static {
+        H2MAP = new HashMap<>();
+        H2MAP.put(Integer.class, "INT");
+        H2MAP.put(Long.class, "INT");
+        H2MAP.put(Byte.class, "INT");
+        H2MAP.put(Short.class, "INT");
+        H2MAP.put(Double.class, "DOUBLE");
+        H2MAP.put(Float.class, "DOUBLE");
+        H2MAP.put(String.class, "VARCHAR(10)");
+        H2MAP.put(Character.class, "VARCHAR(10)");
+        H2MAP.put(Integer.TYPE, "INT");
+        H2MAP.put(Long.TYPE, "INT");
+        H2MAP.put(Byte.TYPE, "INT");
+        H2MAP.put(Short.TYPE, "INT");
+        H2MAP.put(Double.TYPE, "DOUBLE");
+        H2MAP.put(Float.TYPE, "DOUBLE");
+        H2MAP.put(Character.TYPE, "VARCHAR(10)");
+    }
+
+}
diff --git a/solutions/krakhmalev/Annotations/Column.java b/solutions/krakhmalev/Annotations/Column.java
new file mode 100644
index 0000000..1d759b0
--- /dev/null
+++ b/solutions/krakhmalev/Annotations/Column.java
@@ -0,0 +1,9 @@
+package ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations;
+
+import java.lang.annotation.*;
+
+@Target(value=ElementType.FIELD)
+@Retention(value= RetentionPolicy.RUNTIME)
+public @interface Column {
+    String name() default "";
+}
diff --git a/solutions/krakhmalev/Annotations/PrimaryKey.java b/solutions/krakhmalev/Annotations/PrimaryKey.java
new file mode 100644
index 0000000..f57d2b8
--- /dev/null
+++ b/solutions/krakhmalev/Annotations/PrimaryKey.java
@@ -0,0 +1,9 @@
+package ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations;
+
+import  java.lang.annotation.*;
+
+
+@Target(value=ElementType.FIELD)
+@Retention(value= RetentionPolicy.RUNTIME)
+public @interface PrimaryKey {
+}
diff --git a/solutions/krakhmalev/Annotations/Table.java b/solutions/krakhmalev/Annotations/Table.java
new file mode 100644
index 0000000..2df99c1
--- /dev/null
+++ b/solutions/krakhmalev/Annotations/Table.java
@@ -0,0 +1,9 @@
+package ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations;
+
+import java.lang.annotation.*;
+
+@Target(value=ElementType.TYPE)
+@Retention(value= RetentionPolicy.RUNTIME)
+public @interface Table {
+    String name() default "";
+}
diff --git a/solutions/krakhmalev/BlockingQueue.java b/solutions/krakhmalev/BlockingQueue.java
new file mode 100644
index 0000000..3712852
--- /dev/null
+++ b/solutions/krakhmalev/BlockingQueue.java
@@ -0,0 +1,108 @@
+package ru.fizteh.fivt.students.krakhmalev.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;
+            }
+        }
+    }
+}
+
diff --git a/solutions/krakhmalev/Counter.java b/solutions/krakhmalev/Counter.java
new file mode 100644
index 0000000..8d4f9ce
--- /dev/null
+++ b/solutions/krakhmalev/Counter.java
@@ -0,0 +1,55 @@
+package ru.fizteh.fivt.students.krakhmalev.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();
+        }
+    }
+}
+
diff --git a/solutions/krakhmalev/DataBaseService.java b/solutions/krakhmalev/DataBaseService.java
new file mode 100644
index 0000000..ee71699
--- /dev/null
+++ b/solutions/krakhmalev/DataBaseService.java
@@ -0,0 +1,214 @@
+import com.google.common.base.CaseFormat;
+import com.tngtech.java.junit.dataprovider.internal.DataConverter;
+import ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations.Column;
+import ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations.PrimaryKey;
+import ru.fizteh.fivt.students.krakhmalev.MiniORM.Annotations.Table;
+
+import javax.management.OperationsException;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Field;
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DataBaseService <T,K>{
+    private Connection connection = null;
+    private Statement statement = null;
+    private ResultSet resultSet = null;
+    private Field primaryKey = null;
+    private List<AnnotatedField> columns = null;
+    private Class<T> typeClass = null;
+    private String tableName = "";
+    int primaryKeyIndex = -1;
+
+    private boolean hasTableYet = false;
+
+    private void connect() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {
+        Class.forName("org.h2.Driver").newInstance();
+        connection = DriverManager.getConnection("jdbc:h2:test",
+                "sa", "");
+        statement = connection.createStatement();
+    }
+
+    protected void finalize ( ) throws SQLException {
+        resultSet.close();
+        statement.close();
+        connection.close();
+    }
+
+    DataBaseService(Class<T> elementClass) throws ClassNotFoundException, SQLException, InstantiationException, IllegalAccessException {
+        try{
+            this.connect();
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+        columns = new ArrayList<>();
+        typeClass = elementClass;
+        Table table = typeClass.getAnnotation(Table.class);
+        if (table == null) {
+            throw new IllegalArgumentException("Class should be annotated with Table");
+        }
+        tableName = table.name();
+        if (tableName.equals("")) {
+            tableName = "MY_TABLE";
+        }
+        int i = 0;
+        for (Field elem : typeClass.getDeclaredFields()) {
+            if (elem.getAnnotation(Column.class) != null) {
+                columns.add(new AnnotatedField(elem));
+            }
+            if (elem.getAnnotation(PrimaryKey.class) != null) {
+                if (elem.getAnnotation(Column.class) == null) {
+                    throw new IllegalArgumentException("Первичный ключ должен иметь тип столбца");
+                }
+                if (primaryKey != null) {
+                    throw new IllegalArgumentException("Первичный ключ долден быть один");
+                }
+                primaryKey = elem;
+                primaryKeyIndex = i;
+            }
+            ++i;
+        }
+        try{
+            resultSet = connection.getMetaData().getTables(null, null,
+                            CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_UNDERSCORE, tableName), null);
+            if (resultSet.next()) {
+                hasTableYet = true;
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+
+    }
+
+
+
+    public T queryById(K id) throws OperationsException, SQLException, IllegalAccessException, InstantiationException {
+        if (!hasTableYet){
+            throw new OperationsException("Для данного запроа необходимо создать таблицу");
+        }
+        if (primaryKey == null){
+            throw new OperationsException("Должен суущестовать первичный ключ");
+        }
+        if (!id.getClass().isInstance(primaryKey.getType())){
+            throw new IllegalArgumentException("Ключ должен иметь тот же тип, что и первичные ключи таблицы");
+        }
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("SELECT * FROM ").append(tableName).append(" WERE ")
+                .append(columns.get(primaryKeyIndex).getColumnName()).append(" = ").append(id.toString());
+        resultSet = statement.executeQuery(newRequest.toString());
+        List<T> list = new ArrayList<>();
+        while (resultSet.next()) {
+            T item = typeClass.newInstance();
+            for (AnnotatedField field: columns) {
+                if (field.getElement().getType().equals(Integer.class)) {
+                    field.getElement().set(item, resultSet.getInt(field.getColumnName()));
+                }
+                if (field.getElement().getType().equals(String.class)) {
+                    field.getElement().set(item, resultSet.getString(field.getColumnName()));
+                }
+            }
+            list.add(item);
+        }
+        if (list.size() == 0) {
+            return null;
+        }
+        if (list.size() > 1) {
+            throw new OperationsException("Ошибка получения результата");
+        }
+        return list.get(0);
+    }
+
+    List<T> queryForAll() throws OperationsException, SQLException, IllegalAccessException, InstantiationException {
+
+        if (!hasTableYet){
+            throw new OperationsException("Для данного запроа необходимо создать таблицу");
+        }
+        if (primaryKey == null){
+            throw new OperationsException("Должен суущестовать первичный ключ");
+        }
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("SELECT * FROM ").append(tableName);
+        resultSet = statement.executeQuery(newRequest.toString());
+        List<T> list = new ArrayList<>();
+        while (resultSet.next()) {
+            T item = typeClass.newInstance();
+            for (AnnotatedField field: columns) {
+                if (field.getElement().getType().equals(Integer.class)) {
+                    field.getElement().set(item, resultSet.getInt(field.getColumnName()));
+                }
+                if (field.getElement().getType().equals(String.class)) {
+                    field.getElement().set(item, resultSet.getString(field.getColumnName()));
+                }
+            }
+            list.add(item);
+        }
+        return list;
+    }
+
+    void insert(T key) throws SQLException {
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("INSERT INTO").append(tableName).append(" (");
+        boolean first = true;
+        for (AnnotatedField field:columns){
+            if (!first){
+                newRequest.append(", ");
+            }else {
+                first = false;
+            }
+            newRequest.append(field.getColumnName());
+        }
+        statement.execute(newRequest.toString());
+
+    }
+
+    void update(T key) throws SQLException {
+        StringBuilder newRequest = new StringBuilder().append("UPDATE ").append(tableName).append(" SET ");
+        for (int i = 0; i < columns.size(); ++i) {
+            if (i != 0) {
+                newRequest.append(", ");
+            }
+            newRequest.append(columns.get(i).getColumnName()).append(" = ?");
+        }
+        newRequest.append(" WHERE ").append(columns.get(primaryKeyIndex).getColumnName())
+                .append(" = ?");
+        statement.execute(newRequest.toString());
+    }
+
+
+    void delete(T key) throws SQLException {
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("DELETE FROM ").append(tableName).append(columns.get(primaryKeyIndex).getColumnName()).append(" = ").append(key.toString());
+        statement.execute(newRequest.toString());
+    }
+
+    void createTable() throws OperationsException, SQLException {
+        if (hasTableYet) {
+            throw new OperationsException("Невозможно повторно создать таблицу");
+        }
+        StringBuilder newRequest = new StringBuilder();
+        newRequest.append("CREATE TABLE ").append(tableName).append(" (");
+        int i = 0;
+        for (AnnotatedField field : columns) {
+            newRequest.append(field.getColumnName()).append(" ");
+            newRequest.append(field.getH2Type()).append(" ");
+            if (field.getElement().isAnnotationPresent(PrimaryKey.class)) {
+                newRequest.append("NOT NULL PRIMARY KEY ");
+                primaryKeyIndex = i;
+            }
+            i++;
+            newRequest.append(" , ");
+        }
+        newRequest.append(") ");
+        statement.execute(newRequest.toString());
+    }
+
+    void dropTable(){
+        try {
+            statement.execute("DROP TABLE " + tableName);
+            hasTableYet = false;
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/solutions/krakhmalev/Reverser b/solutions/krakhmalev/Reverser
new file mode 100644
index 0000000..8b8ca31
--- /dev/null
+++ b/solutions/krakhmalev/Reverser
@@ -0,0 +1,15 @@
+public class Reverser
+{  
+	public static void main(String[] args) 
+	{  
+    		for (int i = args.length - 1; i >= 0; i--) 
+    		{  
+        		String[] numbers = args[i].split("\\s+");  
+          		for (int j = numbers.length - 1; j >= 0; j--) 
+          		{  
+             			System.out.print(numbers[j] + " ");  
+         		}  
+     		}  
+   	}  
+}  
+
diff --git a/solutions/krakhmalev/RollCall.java b/solutions/krakhmalev/RollCall.java
new file mode 100644
index 0000000..3bd6fa9
--- /dev/null
+++ b/solutions/krakhmalev/RollCall.java
@@ -0,0 +1,80 @@
+package ru.fizteh.fivt.students.krakhmalev.Threads;
+
+import java.util.Random;
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+
+public class RollCall {
+
+    private static volatile boolean allReady;
+    private static boolean finish;
+    private static volatile Random chance = new Random();
+    private static CyclicBarrier beginAnswer;
+    private static CyclicBarrier endAnswer;
+    private static final int NOT_READY_PROBABILITY = 10;
+
+    private static class Player extends Thread {
+
+        @Override
+        public void run() {
+            while (!finish) {
+                try {
+                    beginAnswer.await();
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+                if (chance.nextInt(100) > NOT_READY_PROBABILITY) {
+                    System.out.println("Yes");
+                } else {
+                    System.out.println("No");
+                    allReady = false;
+                }
+                try {
+                    endAnswer.await();
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+
+
+    }
+
+    public static void main(String[] args) {
+        if (args.length != 1) {
+            throw new IllegalArgumentException();
+        }
+        finish = false;
+        int n = Integer.valueOf(args[0]);
+        beginAnswer = new CyclicBarrier(n + 1);
+        endAnswer = new CyclicBarrier(n + 1);
+        Player[] players = new Player[n];
+        for (int i = 0; i < n; i++) {
+            players[i] = new Player();
+            players[i].start();
+        }
+        finish = false;
+        while (!finish) {
+            System.out.println("Are you ready?");
+            allReady = true;
+            try {
+                beginAnswer.await();
+            } catch (BrokenBarrierException | InterruptedException e) {
+                e.printStackTrace();
+            }
+            beginAnswer.reset();
+            try {
+                endAnswer.await();
+                if (allReady) {
+                    finish = true;
+                    for (int i = 0; i < n; i++) {
+                        players[i].join();
+                    }
+                    System.exit(0);
+                }
+            } catch (BrokenBarrierException | InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}