Java 即使第一个线程使用ReentrantLock锁定，第二个线程也会执行

我是Java新手，试图通过实现学习Java概念。 这里使用ReentrantLock类的原因是为了理解锁

我正在生成3个线程，在这些线程中，我只是增加了一个全局计数器。 我正在使用锁保护被其他线程覆盖的计数器

import java.util.concurrent.locks.ReentrantLock;

class ReentryHandledSingleThread extends Thread
{
    static long counter = 0;

    private int myId;

    private final ReentrantLock myLock = new ReentrantLock();

    public ReentryHandledSingleThread(int id)
    {
        this.myId = id;
    }

    public void incrementTheCounter()
    {

        long stackvariable;
        int i;

        for (i = 0; i < 10000; i++)
        {
            stackvariable = ReentryHandledSingleThread.counter;
            stackvariable = stackvariable + 1;
            ReentryHandledSingleThread.counter = stackvariable;
        }
        System.out.println("The value from counter is " + ReentryHandledSingleThread.counter);
        return;

    }

    public void run()
    {
        System.out.println("Started Thread No. " + this.myId);
        this.myLock.lock();
        {
            System.out.println("LOCKED Thread No. " + this.myId);
            this.incrementTheCounter();
        }
        System.out.println("UNLOCKED   Thread No." + this.myId);
        this.myLock.unlock();

    }
}

public class RentryHandle
{

    public static void main(String[] args)
    {
        System.out.println("Started Executing Main Thread");
        int noOfThreads = 3;
        ReentryHandledSingleThread threads[] = new ReentryHandledSingleThread[noOfThreads];
        for (int j = 0; j < noOfThreads; j++)
        {
            threads[j] = new ReentryHandledSingleThread(j);
        }

        for (int j = 0; j < noOfThreads; j++)
        {
            threads[j].start();
        }

        for (int j = 0; j < noOfThreads; j++)
        {
            try

            {
                threads[j].join();
            }
            catch (InterruptedException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
        System.out.println("Finished Executing Main thrread");

    }
}

我的预期产出

我通过了 然而，我不在这里使用

条件等待

因此，我无法与我的实施合作。

---

请帮助我理解这个错误，或者理解我的实现中的ReentrantLock应用程序，它导致了Expected Output和Observed Output之间的差异。

问题是每个线程对象都有自己的锁（并且能够独立于所有其他线程所做的事情来锁定它）：

---

如果您希望在线程之间共享锁，请将上述对象设置为static

谢谢您，先生..在设置私有最终ReentrantLock myLock=new ReentrantLock（）之后；as private static final ReentrantLock myLock=new ReentrantLock（）；我能够得到预期的产出。

    Started Executing Main Thread 
    Started Thread No. 0 
    LOCKED Thread No.   0 
    Started Thread No. 2 
    LOCKED Thread No. 2 
    The value from counter is   10226 
    UNLOCKED   Thread No.0 
    The value from counter is 16165 
    UNLOCKED   Thread No.2 
    Started Thread No. 1 
    LOCKED Thread No. 1 
    The value from   counter is 26165 
    UNLOCKED   Thread No.1 
    Finished Executing Main   thrread

    Started Executing Main Thread
    Started Thread No. 0
    LOCKED Thread No. 0
    The value from counter is 10000
    UNLOCKED   Thread No.0
    Started Thread No. 1
    LOCKED Thread No. 1
    The value from counter is 20000
    UNLOCKED   Thread No.1
    Started Thread No. 2
    LOCKED Thread No. 2
    The value from counter is 30000
    UNLOCKED   Thread No.2
    Finished Executing Main thrread

private final ReentrantLock myLock = new ReentrantLock();