class Program
{
const int MAGIC_NUMBER = 250000;
ConcurrentDictionary<Int32, Int32> c = new ConcurrentDictionary<Int32, Int32>();
public Program()
{
Thread[] threads = new Thread[6];
int i = 0;
for (; i < 4; i++)
{
int temp = i + 1;
threads[i] = new Thread(() => searchFunction(temp));
}
threads[i++] = new Thread(() =>
{
Random r = new Random();
while (true)
{
try
{
for (int j = 0; j < 10000; j++)
{
int num = r.Next();
c.TryAdd(num, num);
}
Thread.Sleep(10);
}
catch (ThreadInterruptedException)
{
return;
}
}
});
threads[i++] = new Thread(() =>
{
Random r = new Random();
while (true)
{
try
{
c.TryAdd(MAGIC_NUMBER, MAGIC_NUMBER);
Console.WriteLine("-->Thread 6: Magic Number Inserted");
Thread.Sleep(5000);
}
catch (ThreadInterruptedException)
{
return;
}
}
});
for (int j = 0; j < threads.Length; j++)
threads[j].Start();
Thread.Sleep(100000);
for (int j = 0; j < threads.Length; j++)
threads[j].Interrupt();
}
void searchFunction(int i)
{
int count = i;
while (true)
{
try
{
Int32 outNum;
bool b = c.TryRemove(MAGIC_NUMBER, out outNum);
if (b == true)
{
c.Clear();
Console.WriteLine("Thread " + count + ": Magic Number found. Object id: " + RuntimeHelpers.GetHashCode(outNum));
}
Thread.Sleep(10);
}
catch (ThreadInterruptedException)
{
return;
}
}
}
static void Main(string[] args)
{
new Program();
}
}
ConcurrentHashMap in Java
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
public class Concurrenthashmap {
static final int MAGIC_NUMBER = 250000;
ConcurrentHashMap<Integer, Integer> c = new ConcurrentHashMap<Integer, Integer>();
class searchClass implements Runnable
{
int id;
public searchClass(int id) {
this.id = id;
}
@Override
public void run() {
Integer i = new Integer(MAGIC_NUMBER);
while(true)
{
try {
Integer o = c.remove(i);
if(o != null)
{
c.clear();
System.out.println("Thread " + id + ": Magic Number found. Object id: " + System.identityHashCode(o));
}
Thread.sleep(10);
} catch (InterruptedException e) {
return;
}
}
}
}
public Concurrenthashmap() {
Thread [] threads = new Thread[6];
int i = 0;
for(; i < 4; i++)
threads[i] = new Thread(new searchClass(i + 1));
threads[i++] = new Thread(new Runnable() {
@Override
public void run() {
Random r = new Random();
while(true)
{
try {
for(int i = 0; i < 10000; i++)
{
int num = r.nextInt();
c.put(num, num);
}
Thread.sleep(10);
} catch (InterruptedException e) {
return;
}
}
}
});
threads[i++] = new Thread(new Runnable() {
@Override
public void run() {
while(true)
{
try {
c.put(MAGIC_NUMBER, MAGIC_NUMBER);
System.out.println("-->Thread 6: Magic Number Inserted");
Thread.sleep(5000);
} catch (InterruptedException e) {
return;
}
}
}
});
for(int j = 0; j < threads.length; j++)
threads[j].start();
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
}
for(int j = 0; j < threads.length; j++)
threads[j].interrupt();
}
public static void main(String[] args) {
new Concurrenthashmap();
}
}
Barrier in C#
class Program
{
Barrier b = new Barrier(3);
public Program()
{
Thread[] threads = new Thread[4];
for (int i = 0; i < 4; i++)
{
threads[i] = new Thread(doSomething);
threads[i].Start(i + 1);
}
Thread.Sleep(30000);
for (int i = 0; i < 6; i++)
{
threads[i].Interrupt();
}
}
void doSomething(object id)
{
int length = ((int)id) * 2;
while (true)
{
try
{
Console.WriteLine("Thread " + id + ": Doing something for " + length + " seconds.");
Thread.Sleep(length * 1000);
Console.WriteLine("Thread " + id + ": Waiting");
b.SignalAndWait();
}
catch (ThreadInterruptedException)
{
return;
}
}
}
static void Main(string[] args)
{
new Program();
}
}
SemaphoreSlim in C#
class Program
{
SemaphoreSlim sem = new SemaphoreSlim(2);
public Program()
{
Thread []threads = new Thread[6];
for (int i = 0; i < 6; i++)
{
int t = i + 1;
threads[i] = new Thread(() => doSomething(t * 2, "Thread " + t));
threads[i].Start();
}
}
void doSomething(int length, string str)
{
sem.Wait();
Console.WriteLine(str + ": Doing something for " + length + " seconds.");
Thread.Sleep(length * 1000);
sem.Release();
Console.WriteLine(str + ": Done");
}
static void Main(string[] args)
{
new Program();
}
}
CountdownEvent in C#
class Program
{
CountdownEvent countdown = new CountdownEvent(3);
public Program()
{
Thread t1 = new Thread(() => doSomething(4, "Thread 1"));
Thread t2 = new Thread(() => doSomething(3, "Thread 2"));
Thread t3 = new Thread(() => doSomething(2, "Thread 3"));
t1.Start();
t2.Start();
t3.Start();
t1.Join();
t2.Join();
t3.Join();
}
void doSomething(int length, string str)
{
Console.WriteLine(str + ": Doing Something for " + length);
Thread.Sleep(length * 1000);
Console.WriteLine(str + ": Done");
countdown.Signal();
Console.WriteLine(str + ": Waiting now");
countdown.Wait();
Console.WriteLine(str + ": Doing something else now for 3 seconds");
Thread.Sleep(3000);
Console.WriteLine(str + ": Done");
}
static void Main(string[] args)
{
new Program();
}
}
Locks in C#
class Program
{
class numberBasketClass
{
ArrayList al = new ArrayList();
Object obj = new Object();
public void LessThen10()
{
while (true)
{
lock (obj)
{
Console.WriteLine("Start Adding 10");
for (int i = 0; i < 9; i++)
al.Add(i);
Console.WriteLine("Done Adding 10");
Thread.Sleep(2000);
}
}
}
public void LessThen20()
{
while (true)
{
lock (obj)
{
Console.WriteLine("Start Adding 20");
for (int i = 10; i < 20; i++)
al.Add(i);
Console.WriteLine("Done Adding 20");
}
}
}
public void Keep15()
{
while (true)
{
lock (obj)
{
Console.WriteLine("Start Removing");
while (al.Count > 100)
al.RemoveRange(0, al.Count - 100);
Console.WriteLine("Done Removing");
Thread.Sleep(2000);
}
}
}
}
static void Main(string[] args)
{
numberBasketClass b = new numberBasketClass();
Thread t1 = new Thread(new ThreadStart(b.LessThen10));
t1.Start();
Thread t2 = new Thread(new ThreadStart(b.LessThen20));
t2.Start();
Thread t3 = new Thread(new ThreadStart(b.Keep15));
t3.Start();
Thread.Sleep(10000);
t1.Abort();
t2.Abort();
t3.Abort();
}
}
Threading in C#
class Program
{
static void Main(string[] args)
{
Thread t = new Thread(new ThreadStart(Work));
t.Start();
t.Join();
Task <string> task = Task.Factory.StartNew<string>(() =>
{
Console.WriteLine("working for 4 seconds!");
Thread.Sleep(4000);
Console.WriteLine("done");
return "NO ERROR.";
});
task.Wait();
Console.WriteLine(task.Result);
}
static void Work()
{
Console.WriteLine("working for 3 seconds!");
Thread.Sleep(3000);
Console.WriteLine("done");
}
}
Postfix Calculator in Java
Element.java
package com.tutorial;
public interface Element {
}
NumberElement.java
package com.tutorial;
public class NumberElement implements Element {
Double number;
public Double getNumber() {
return number;
}
public NumberElement(String number) {
this.number = Double.parseDouble(number);
}
public String toString()
{
return ((Integer)number.intValue()).toString();
}
}
OperatorElement.java
package com.tutorial;
public class OperatorElement implements Element{
static public enum OperatorType {MULTIPLY, DIVIDE, ADD, SUBTRACT, EXPONENTIAL, OPAREN, CPAREN};
OperatorType type;
Character c;
public OperatorElement(Character operator) {
c = operator;
if(operator == '+')
type = OperatorType.ADD;
else if(operator == '-')
type = OperatorType.SUBTRACT;
else if(operator == '*')
type = OperatorType.MULTIPLY;
else if(operator == '/')
type = OperatorType.DIVIDE;
else if(operator == '^')
type = OperatorType.EXPONENTIAL;
else if(operator == '(')
type = OperatorType.OPAREN;
else if(operator == ')')
type = OperatorType.CPAREN;
}
public String toString()
{
return c.toString();
}
}
Parser.java
package com.tutorial;
import java.util.Collection;
import java.util.Vector;
public class Parser {
Vector <Element> e = new Vector<Element>();
public Collection<Element> Parse(String s)
{
StringBuilder sb = new StringBuilder();
for(int i = 0; i < s.length(); i++)
{
Character c = s.charAt(i);
if(Character.isDigit(c))
sb.append(c);
if(i + 1 < s.length())
{
Character d = s.charAt(i + 1);
if(Character.isDigit(d) == false && sb.length() > 0)
{
e.add(new NumberElement(sb.toString()));
//clears stringbuilder
sb.delete(0, sb.length());
}
}
if(c == '+' || c == '-' || c == '*' || c == '/' || c == '^'
|| c == '(' || c == ')')
e.add(new OperatorElement(c));
}
if(sb.length() > 0)
e.add(new NumberElement(sb.toString()));
return e;
}
}
InfixToPostfix.java
package com.tutorial;
import java.util.Collection;
import java.util.Stack;
import java.util.Vector;
import com.tutorial.OperatorElement.OperatorType;
public class InfixToPostfix {
Vector <Element> converted = new Vector<Element>();
int Precedence(OperatorElement c)
{
if(c.type == OperatorType.EXPONENTIAL)
return 2;
else if(c.type == OperatorType.MULTIPLY || c.type == OperatorType.DIVIDE)
return 3;
else if(c.type == OperatorType.ADD || c.type == OperatorType.SUBTRACT)
return 4;
else
return Integer.MAX_VALUE;
}
public void ProcessOperators(Stack<Element> st, Element element, Element top)
{
while(st.size() > 0 && Precedence((OperatorElement)element) >= Precedence((OperatorElement)top))
{
Element p = st.pop();
if(((OperatorElement)p).type == OperatorType.OPAREN)
break;
converted.add(p);
if(st.size() > 0)
top = st.lastElement();
}
}
public Collection<Element> ConvertFromInfixToPostFix(Collection<Element> e)
{
Vector <Element> stack1 = new Vector<Element>(e);
Stack<Element> st = new Stack<Element>();
for(int i = 0; i < stack1.size(); i++)
{
Element element = stack1.elementAt(i);
if(element instanceof OperatorElement)
{
if(st.empty() ||
((OperatorElement)element).type == OperatorType.OPAREN)
st.push(element);
else
{
Element top = st.lastElement();
if(((OperatorElement)element).type == OperatorType.CPAREN)
ProcessOperators(st, element, top);
else if(Precedence((OperatorElement)element) < Precedence((OperatorElement)top))
st.push(element);
else
{
ProcessOperators(st, element, top);
st.push(element);
}
}
}
else
converted.add(element);
}
//pop all operators in stack
while(st.size() > 0)
{
Element b1 = st.pop();
converted.add(b1);
}
return converted;
}
public String toString()
{
StringBuilder s = new StringBuilder();
for(int j = 0; j < converted.size(); j++)
s.append(converted.elementAt(j) + " ");
return s.toString();
}
}
PostFixEvaluator.java
package com.tutorial;
import java.util.Collection;
import java.util.Stack;
import java.util.Vector;
import com.tutorial.OperatorElement.OperatorType;
public class PostFixEvaluator {
Stack<Element> stack = new Stack<Element>();
NumberElement calculate(NumberElement left, NumberElement right, OperatorElement op)
{
Double temp = Double.MAX_VALUE;
if(op.type == OperatorType.ADD)
temp = left.getNumber() + right.getNumber();
else if(op.type == OperatorType.SUBTRACT)
temp = left.getNumber() - right.getNumber();
else if(op.type == OperatorType.MULTIPLY)
temp = left.getNumber() * right.getNumber();
else if(op.type == OperatorType.DIVIDE)
temp = left.getNumber() / right.getNumber();
else if(op.type == OperatorType.EXPONENTIAL)
temp = Math.pow(left.getNumber(), right.getNumber());
return new NumberElement(temp.toString());
}
public Double Evaluate(Collection<Element> e)
{
Vector <Element> v = new Vector<Element>(e);
for(int i = 0; i < v.size(); i++)
{
Element element = v.elementAt(i);
if(element instanceof NumberElement)
stack.push(element);
if(element instanceof OperatorElement)
{
NumberElement right = (NumberElement) stack.pop();
NumberElement left = (NumberElement) stack.pop();
NumberElement result = calculate(left, right, (OperatorElement)element);
stack.push(result);
}
}
return ((NumberElement)stack.pop()).getNumber();
}
}
CalculatorTest.java
package com.tutorial;
import java.util.Collection;
public class CalculatorTest {
public double Calculate(String s)
{
Parser p = new Parser();
Collection<Element> e = p.Parse(s);
InfixToPostfix i = new InfixToPostfix();
e = i.ConvertFromInfixToPostFix(e);
//debugging
System.out.println("DEBUGGING: " + i.toString());
//
PostFixEvaluator pfe = new PostFixEvaluator();
return pfe.Evaluate(e);
}
public static void main(String[] args) {
CalculatorTest c = new CalculatorTest();
double d = c.Calculate("4+6+9*8-(5*6+9)^2");
System.out.println(d);
}
}
CSV Parser (using State Machine) in Java
import java.util.ArrayList;
public class CSVParser {
public enum OPstates
{
INITIAL(0),
NORMAL(1),
COMMA(2),
OPEN_QUOTATION(9),
CLOSE_QUOTATION(4),
WHITE_SPACE(5),
QUOTATION_IN_TOKEN(6),
CLOSE_QUOTATION_IN_TOKEN(8),
ERROR(-1),
NEW_LINE(200);
int i;
private OPstates(int i) {
this.i = i;
}
public int getValue()
{
return i;
}
}
int [][] state = { {1, 2, 3, 200, 5}, //0 initial state
{1, 2, -1, 200, 1}, //1 normal character state
{1, 2, 3, 200, 5}, //2 comma state
{9, 9, 4, -1, 9}, //3 open quotation
{-1, 2, 6, 200, 5}, //4 close quotation or quotation in token state
{1, 2, 3, 200, 5}, //5 whitespace state
{6, 6, 7, 200, 6}, //6 quotation in token
{-1, -1, 8, -1, -1}, //7 close quotation
{9, -1, 4, 200, 9}, //8 close quotation
{9, 9, 4, -1, 9} //9 open quotation state
};
ArrayList<String> tokens = new ArrayList<String>();
int TokenState(char token)
{
if(token == ',')
return 1;
else if(token == '"')
return 2;
else if(token == '\n')
return 3;
else if(token == ' ')
return 4;
else
return 0;
}
void Parse(String input)
{
int curState = 0;
StringBuilder sb = new StringBuilder();
for(int i = 0; i < input.length(); i++)
{
char tokenChar = input.charAt(i);
int tokenState = TokenState(tokenChar);
curState = state[curState][tokenState];
if(curState == OPstates.NORMAL.getValue() ||
curState == OPstates.OPEN_QUOTATION.getValue() ||
curState == OPstates.QUOTATION_IN_TOKEN.getValue() ||
curState == OPstates.CLOSE_QUOTATION_IN_TOKEN.getValue())
sb.append(tokenChar);
if(curState == OPstates.COMMA.getValue() ||
curState == OPstates.NEW_LINE.getValue())
{
tokens.add(sb.toString().trim());
sb.delete(0, sb.length());
if(curState == OPstates.NEW_LINE.getValue())
break;
}
if(curState == OPstates.ERROR.getValue())
throw new RuntimeException("Parse Error");
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for(int i = 0; i < tokens.size(); i++)
sb.append("Token: " + tokens.get(i) + "\n");
return sb.toString().trim() + "\n";
}
public CSVParser(String input) {
Parse(input);
}
public static void main(String[] args) {
String s = " \"a\" , \"b,cd\" , c ,\"vb, n\",\",\"\n";
System.out.println(s + new CSVParser(s));
s = " , a,b,\"c, l\",d,,5\n";
System.out.println(s + new CSVParser(s));
s = "h,\"john, jr\",a,b,\"c, l\",d,,5,\"e, jr\"\n";
System.out.println(s + new CSVParser(s));
s = "\"h, jk\",\"john, jr\",a,b,\"c, l\",d,,5,\"e's, jr\"\n";
System.out.println(s + new CSVParser(s));
s = "\" e \"\"abc\"\" n \"\"def\"\" \"\"buddy\"\"d\",\"b, jr\", c dj n\n";
System.out.println(s + new CSVParser(s));
}
}
CyclicBarrier in Java
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierTest {
class runnable implements Runnable
{
int length;
int id;
public runnable(int id, int length) {
this.length = length;
this.id = id;
}
@Override
public void run() {
while(true)
{
try {
System.out.println("Doing something for " + length + " seconds");
Thread.sleep(length * 1000);
System.out.println("Thread " + id + ": waiting");
c.await();
} catch (InterruptedException e) {
return;
} catch (BrokenBarrierException e) {
return;
}
if(Thread.interrupted())
return;
}
}
}
CyclicBarrier c = new CyclicBarrier(3);
Thread t1;
Thread t2;
Thread t3;
public CyclicBarrierTest()
{
t1 = new Thread(new runnable(1, 1));
t2 = new Thread(new runnable(2, 3));
t3 = new Thread(new runnable(3, 9));
t1.start();
t2.start();
t3.start();
}
public void stop()
{
t1.interrupt();
t2.interrupt();
t3.interrupt();
}
public static void main(String[] args) {
CyclicBarrierTest b = new CyclicBarrierTest();
try {
Thread.sleep(60000);
} catch (InterruptedException e) {
e.printStackTrace();
}
b.stop();
}
}
Random Code Generator 