sunil-the-coder · sunil-the-coder · Apr 2, 2019 · Apr 3, 2019 · Apr 3, 2019 · Apr 4, 2019
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,6 @@
+*.class
+/.metadata/
+*/*.classpath
+*/*.settings
+*/*.project
+*/*/WebContent/WEB-INF/lib/*.jar
diff --git a/Account.java b/Account.java
@@ -0,0 +1,34 @@
+package com.itp.threads;
+
+public class Account {
+
+	// state of the object
+	private int balance;
+
+	public Account(int balance) {
+		this.balance = balance;
+	}
+
+	public void deposit(int amount) {
+		synchronized (this) {
+			this.balance += amount;			
+		}
+		System.out.println("After Deposit:" + this.balance);
+	}
+
+	public synchronized void withdraw(int amount) {
+		if (this.balance < amount) {
+			System.out.println("Insufficient Balance to withraw");
+		}
+
+		synchronized (this) {
+			this.balance -= amount;			
+		}
+
+		System.out.println("After Withdraw:" + this.balance);
+	}
+
+	public int getFinalBalance() {
+		return balance;
+	}
+}
diff --git a/AccountTest.java b/AccountTest.java
@@ -0,0 +1,57 @@
+package com.itp.threads;
+
+class DepositThread implements Runnable {
+
+	// Refer to existing account object
+	private Account account;
+
+	public DepositThread(Account account) {
+		this.account = account;
+	}
+
+	@Override
+	public void run() {
+		for (int i = 1; i <= 5; i++)
+			account.deposit(500);
+	}
+}
+
+class WithdrawThread implements Runnable {
+
+	// Refer to existing account object
+	private Account account;
+
+	public WithdrawThread(Account account) {
+		this.account = account;
+	}
+
+	@Override
+	public void run() {
+		for (int i = 1; i <= 5; i++)
+			account.withdraw(500);
+	}
+}
+
+public class AccountTest {
+
+	public static void main(String[] args) {
+
+		// Create account object
+		Account joinAccount = new Account(5000);
+
+		Thread depositThread = new Thread(new DepositThread(joinAccount));
+		Thread withdrawThread = new Thread(new WithdrawThread(joinAccount));
+
+		depositThread.start();
+		withdrawThread.start();
+
+		try {
+			depositThread.join();
+			withdrawThread.join();
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+
+		System.out.println("Final Balance:" + joinAccount.getFinalBalance());
+	}
+}
diff --git a/Car.java b/Car.java
@@ -0,0 +1,33 @@
+public class Car
+{
+	private int model;
+	private String name;
+
+	public Car(int model, String name) {
+		this.name = name;
+		this.model = model;
+	}
+
+	public boolean equals(Object obj) {
+		if(this == obj) return true;
+		if(obj != null && obj instanceof Car) {
+			//content comparison
+			Car c2 = (Car)obj;
+			//if(this.model == c2.model)
+
+			if(this.name.equals(c2.name))
+				return true;
+		}
+
+		return false;
+	}
+
+	public static void  main(String[] args)
+	{
+		Car c1 = new Car(10,"BMW");
+		Car c2 = new Car(10,"Swift");
+
+		System.out.println(c1.equals(c2));
+	}
+}
+
diff --git a/DBTest.java b/DBTest.java
@@ -0,0 +1,56 @@
+package com.itp.threads;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.regex.Pattern;
+
+public class DBTest {
+
+	public static void main(String[] args) {
+
+		Connection conn = null;
+		PreparedStatement ps = null;
+		ResultSet rs = null;
+
+		try {
+			// 1. Load the driver into memory
+			//Class.forName("com.mysql.jdbc.Driver");
+
+			// 2. Obtain the database connection
+			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/nobel", "sunil", "sunil@123");
+
+			// 3. Prepare Statement / PreparedStatement
+			String query = "select * from student";
+			ps = conn.prepareStatement(query);
+
+			// 4. Execute the query using statement
+			rs = ps.executeQuery();
+
+			while (rs.next()) {
+				int id = rs.getInt("id");
+				// rs.getString("name")
+				String name = rs.getString(2);
+				System.out.println(id + "\t" + name);
+			}
+
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		}finally {
+			try {
+				if(ps != null) ps.close();
+				if(rs!= null) rs.close();
+				if(conn != null) conn.close();
+			} catch (SQLException e) {
+				e.printStackTrace();
+			}
+		}
+
+	}
+}
diff --git a/Mandal.java b/Mandal.java
@@ -0,0 +1 @@
+mandal
diff --git a/PCTest.java b/PCTest.java
@@ -0,0 +1,71 @@
+package com.itp.threads;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+
+class Producer implements Runnable {
+
+	private BlockingQueue<Integer> sharedQueue;
+
+	public Producer(BlockingQueue<Integer> sharedQueue) {
+		this.sharedQueue = sharedQueue;
+	}
+
+	@Override
+	public void run() {
+
+		for (int i = 10; i <= 100; i++) {
+
+			try {
+				this.sharedQueue.put(i);
+				Thread.sleep(500);
+				System.out.println("Produced: " + i);
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+}
+
+class Consumer implements Runnable {
+
+	private BlockingQueue<Integer> sharedQueue;
+
+	public Consumer(BlockingQueue<Integer> sharedQueue) {
+		this.sharedQueue = sharedQueue;
+	}
+
+	@Override
+	public void run() {
+		try {
+			Integer item  = null;
+			while ((item = this.sharedQueue.take()) != 100) {
+				Thread.sleep(500);
+				System.out.println("Consumed: " + item);
+			}
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+
+	}
+}
+
+public class PCTest {
+
+	public static void main(String[] args) {
+
+		BlockingQueue<Integer> sharedQueue = new ArrayBlockingQueue(5);
+
+		Thread producer = new Thread(new Producer(sharedQueue));
+		Thread consumer = new Thread(new Consumer(sharedQueue));
+
+		producer.start();
+		consumer.start();
+
+		/*
+		 * try { producer.join(); consumer.join(); } catch (InterruptedException e) {
+		 * e.printStackTrace(); }
+		 */
+
+	}
+}
diff --git a/README.md b/README.md
@@ -3,7 +3,7 @@
 
 Steps to take latest codebase 
 
-1. git clone https://github.com/sunil-linux/javatraining.git
+1. git clone https://github.com/sunil-the-coder/javatraining.git
 
 2. cd javatraining