Адамян Лилит 496 TwitterStream corrected, Threads Added

solutions/lilitadamyan/TwitterStream/src/SearchTweets.java

@@ -0,0 +1,125 @@
+import twitter4j.*;
+
+import java.io.StringBufferInputStream;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @since Twitter4J 2.1.7
+ */
+public class SearchTweets {
+    /**
+     * Usage: java twitter4j.examples.search.SearchTweets [query]
+     *
+     * @param args search query
+     */
+
+	public static void searchQuery(Query query, boolean isStream, boolean isHideRetweets, int limit) {
+		Twitter twitter = new TwitterFactory().getInstance();
+
+        try {
+            QueryResult result;
+            List<String> tweetsToPrint = new ArrayList<>();
+            do {
+
+                result = twitter.search(query);
+                List<Status> tweets = result.getTweets();
+                StringBuilder sb = new StringBuilder();
+
+                for (Status tweet : tweets) {
+                	if(tweet.isRetweet() && isHideRetweets) {
+                		continue;
+                	}
+                	Date time = tweet.getCreatedAt();
+                	sb.append(time);
+                	String userName = tweet.getUser().getScreenName();
+                	sb.append("	@" + userName +":	");
+                	String text = tweet.getText();
+                	if(tweet.isRetweet()) {
+                		String retweetedName = tweet.getRetweetedStatus().getUser().getScreenName();
+                		sb.append("ретвитнул	@" + retweetedName + ":	");
+                		text = tweet.getRetweetedStatus().getText();
+                	}
+                	sb.append(text);
+                	int retweetedCount = tweet.getRetweetCount();
+                	if(retweetedCount > 0) {
+                		sb.append(" " + retweetedCount + " ретвитов");
+                	}
+                	if(isStream){
+                		System.out.println(sb.toString());
+                	} else if (limit != tweetsToPrint.size()) {
+                		tweetsToPrint.add(sb.toString());
+                	} else {
+                		break;
+                	}
+                	sb.setLength(0);
+                }
+                if(!isStream && limit == tweetsToPrint.size()) {
+                	break;
+                }
+
+            } while ((query = result.nextQuery()) != null);
+
+            if(tweetsToPrint.size() != 0) {
+            	for(int i = 0; i < tweetsToPrint.size(); i++) {
+            		System.out.println(tweetsToPrint.get(i));
+            	}
+            }
+
+        } catch (TwitterException te) {
+            te.printStackTrace();
+            System.out.println("Failed to search tweets: " + te.getMessage());
+            System.exit(-1);
+        }
+	}
+
+	/*java TwitterStream \
+    [--query|-q <query or keywords for stream>] \
+    [--place|-p <location|'nearby'>] \
+    [--stream|-s] \
+    [--hideRetweets] \
+    [--limit|-l <tweets>] \
+    [--help|-h] */
+
+    public static void main(String[] args) {
+    	try{
+    		String queryName = "";
+        	boolean isStream = false;
+        	boolean isHideRetweets = false;
+        	int limit = -1;
+        	for(int i = 0; i < args.length; i++) {
+        		if(args.length == 0) {
+        			throw new IllegalArgumentException("no argument is specified. Valid arguments:");
+        		} else if(args.length > 7) {
+        			throw new IllegalArgumentException("too many arguments. Valid arguments:");
+        		}
+        		if(args[i].equals("-q")) {
+        			queryName = args[i+1];
+        		} else if(args[i].equals("--hideRetweets")) {
+        			isHideRetweets = true;
+        		} else if(args[i].equals("-s")) {
+        			isStream = true;
+        		} else if(args[i].equals("-l")) {
+        			limit = Integer.parseInt(args[i+1]);
+        		} else if(args[i].equals("-h")) {
+        			System.out.println("java TwitterStream "
+					+ "[--query|-q <query or keywords for stream>]"
+					+ "[--stream|-s] [--hideRetweets] "
+					+ "[--limit|-l <tweets>]");
+        		}
+        		if(queryName.isEmpty()) {
+        			throw new IllegalArgumentException("no query is specified. Valid arguments:");
+        		}      		        		
+        	}
+        	Query query = new Query(queryName);
+        	searchQuery(query, isStream, isHideRetweets, limit);
+    	} catch(IllegalArgumentException e) {
+    		System.out.println(e);
+    		System.out.println("java TwitterStream "
+					+ "[--query|-q <query or keywords for stream>]"
+					+ "[--stream|-s] [--hideRetweets] "
+					+ "[--limit|-l <tweets>]");
+    	}
+    }
+}

solutions/lilitadamyan/TwitterStream/twitter4j.properties

@@ -0,0 +1,5 @@
+debug=true
+oauth.consumerKey=tfQklZyJmOBYfOoKuq20wnTL9
+oauth.consumerSecret=o0DMPQwU3nCVeehxrhGi1Ju6z20ng2lDLFkyeCLV20rX0lgMJb
+oauth.accessToken=3845665516-tFCpRfl753dcaJbPlsKWS23uENaLxq1oBVtkf4K
+oauth.accessTokenSecret=p0hqBFPH9G1WsONyQHohCPYP4nu4fRhHWxJFEqDL3PCfD

solutions/lilitadamyan/threads/src/threads/counter/Counter.java

@@ -0,0 +1,55 @@
+package threads.counter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Counter {
+	public static List<Boolean> mutex = new ArrayList<>();
+
+	public static class Helper implements Runnable {
+
+		private final int number;
+
+		public Helper(int number) {
+			this.number = number;
+		}
+
+		@Override
+		public void run() {
+			while(true) {
+				if(!mutex.get(number-1)) {
+					try {
+						Thread.sleep(10);
+					} catch (InterruptedException e1) {
+						// TODO Auto-generated catch block
+						e1.printStackTrace();
+					}
+				} else {
+					System.out.println("thread number = " + number);
+					mutex.set(number-1, false);
+					if(number == mutex.size()) {
+						mutex.set(0, true);
+					} else 
+						mutex.set(number, true);
+				}
+			}
+		}
+
+	}
+
+	public static void main(String[] args) {
+
+		int n = Integer.parseInt(args[0]);
+		List<Thread> threads = new ArrayList<>();
+		mutex.add(true);
+		for (int i = 1; i <n; i++) {
+			threads.add(new Thread(new Helper(i)));
+			mutex.add(false);
+		}
+		threads.add(new Thread(new Helper(n)));
+
+		for (int i = 0; i <threads.size(); i++) {
+			threads.get(i).start();
+		}
+	}
+}

solutions/lilitadamyan/threads/src/threads/roollcall/RollCall.java

@@ -0,0 +1,98 @@
+package threads.roollcall;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+
+
+public class RollCall {
+
+	public static boolean finish = false;
+	public static List<Boolean> mutex = new ArrayList<>();
+
+	public static class Roll implements Runnable {
+
+		private final CyclicBarrier cyclicBarrier;
+		private final int number;
+
+		public Roll(CyclicBarrier cyclicBarrier, int number) {
+			this.cyclicBarrier = cyclicBarrier;
+			this.number = number;
+		}
+
+		@Override
+		public void run() {
+			while(true) {
+
+				Random random = new Random();
+				boolean t = random.nextFloat() < 0.8;
+				try {
+					Thread.sleep(1000);
+				} catch (InterruptedException e1) {
+					// TODO Auto-generated catch block
+					e1.printStackTrace();
+				}
+				if(finish)
+					break;
+				if(t) {
+					System.out.println("Yes");
+					mutex.set(number, true);
+
+				} else {
+					System.out.println("No");
+					mutex.set(number, false);
+				}
+				try {
+					cyclicBarrier.await();
+				} catch (InterruptedException e) {
+					System.out.println("Service one interrupted!");
+					e.printStackTrace();
+				} catch (BrokenBarrierException e) {
+					System.out.println("Service one interrupted!");
+					e.printStackTrace();
+				}
+
+			}
+		}
+
+	}
+
+	public static void main(String[] args) {
+
+		int n = 4;
+		final CyclicBarrier barrier = new CyclicBarrier(n+1);
+		List<Thread> threads = new ArrayList<>();
+		for (int i = 0; i < n; i++) {
+			threads.add(new Thread(new Roll(barrier, i)));
+			mutex.add(false);
+		}
+
+		System.out.println("Are you ready?");
+		for (int i = 0; i <threads.size(); i++) {
+			threads.get(i).start();
+		}
+		while(!finish) {
+
+			try {
+				barrier.await();
+				if(!mutex.contains(false)) {
+					finish = true;
+					break;
+				} else {
+					System.out.println("Are you ready?");
+				}
+
+			} catch (InterruptedException e) {
+				System.out.println("Main Thread interrupted!");
+				e.printStackTrace();
+			} catch (BrokenBarrierException e) {
+				System.out.println("Main Thread interrupted!");
+				e.printStackTrace();
+			}
+		}
+	}
+
+
+}