Difference Between Lock and Monitor in Java Concurrency

// Java program to demonstrate the use of locks 
// This program uses ReentrantLock to safely 
// access a shared resource 
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Geeks {

    // Shared resource accessed by multiple threads
    private static int sharedResource = 0;

    // ReentrantLock for thread synchronization
    private static final Lock lock = new ReentrantLock();

    public static void main(String[] args) {
      
        // Creating two threads to 
        // increment the shared resource
        Thread t1 = new Thread(new IncrementTask());
        Thread t2 = new Thread(new IncrementTask());

        // Start both threads
        t1.start();
        t2.start();

        try {
          
            // Wait for both threads to complete
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted");
        }

        // Print final value of shared resource
        System.out.println("Final value of sharedResource: " 
                           + sharedResource);
    }

    // Task to increment the shared resource
    static class IncrementTask implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
              
                // Acquire the lock
                lock.lock(); 
                try {
                    sharedResource++;
                } finally {
                  
                    // Release the lock
                    lock.unlock(); 
                }
            }
        }
    }
}

// Java Program to Illustrate Monitoe in Java Concurrency
import java.io.*;

class SharedDataPrinter
{

	// Monitor implementation is carried on by
	// Using synchronous method
	synchronized public void display(String str)
	{

		for (int i = 0; i < str.length(); i++)
        {
			System.out.print(str.charAt(i));

			// Try-catch block for exceptions
			// Because sleep() method is used
			try 
            {

			// Making thread to sleep for
			// nanoseconds as passed in the arguments
				Thread.sleep(100);
			}
			catch (Exception e) {
		 }
 	  }
   }
}

class Thread1 extends Thread {

	SharedDataPrinter p;

	// Thread
	public Thread1(SharedDataPrinter p)
	{

		// This keyword refers to current instance itself
		this.p = p;
	}

	// run() method for this thread invoked as
	// start() method is called in the main() method
	public void run()
	{

		// Print statement
		p.display("Geeks");
	}
}

// Class 2 (similar to class 1)
// Helper class extending the Thread class
class Thread2 extends Thread {

	SharedDataPrinter p;

	public Thread2(SharedDataPrinter p) { this.p = p; }

	public void run()
	{

		// Print statement
		p.display(" for Geeks");
	}
}

class Geeks
{
	public static void main(String[] args)
	{

		// Instance of a shared resource used to print
		// strings (single character at a time)
		SharedDataPrinter printer = new SharedDataPrinter();

		// Thread objects sharing data printer
		Thread1 t1 = new Thread1(printer);
		Thread2 t2 = new Thread2(printer);

		t1.start();
		t2.start();
	}
}