Lambda表达方式如何在Java起作用

Question

我有这个代码，但我不理解有一个方法调用以增量的零件。

。

我的理解（这是正确的吗？）T2将在第35行

上创建一个新线程

t3将在第36行中创建一个新线程，然后将其调用。

然后在第41行中，将对T2执行运行方法。在第42行中，将对T3执行运行方法。

package aa.race;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadDemoCounter implements Runnable
{
    int counter;
    int alternate;
    String name;

    public static  int numLoops = 4;
    public static  int numPrints = 1500;
    public ThreadDemoCounter(String n)
    {
        name = n;
        counter = 0;
    }

    // For bonus -- delete method go.  Change main to below code:
    public static void main(String[] args) throws Exception
    {
        ThreadDemoCounter c1 = new ThreadDemoCounter("c1");
        //Run the multithreaded demo a few times
        for (int foo = 0; foo < numLoops; foo++)
        {
            c1.counter = 0;
            Thread t1 = new Thread(c1);
            Thread t2 = new Thread(c1);
            Thread t3 = new Thread(c1::incrementOnly);
            Thread t4 = new Thread(c1::incrementOnly);
            t1.start();
            t2.start();
            t3.start();
            t4.start();

            t1.join();
            t2.join(); //wait for both
            t3.join();
            t4.join(); //wait for both
            System.out.println("c1 = " + c1.counter);
            System.out.println("===== end loop =====");
        }
    }

    public void incrementOnly()
    {
        for (int i =0 ; i < numPrints; i++)
        {
            incrementCounter();
        }
    }
    public void run()
    {
        for (int j = 0; j < numPrints; j++)
        {

            LockFactory.getLock(name).lock();
            System.out.println("counter " + name + " = " + getCounter() + " retrieved by thread: " + Thread.currentThread().getName());
            incrementCounter();
            LockFactory.getLock(name).unlock();
        }
        System.out.println();
    }
    public int getCounter()
    {
        return counter;
    } //start at 0
    public void incrementCounter()
    {
        LockFactory.getLock(name).lock();
        counter++;
        LockFactory.getLock(name).unlock();
    }
}

Answer 1

所有4个构造函数都在调用 Thread(Runnable target)，其中 Runnable是带有方法void run()的@FunctionalInterface。当线程启动时，它将调用Runnable的run()方法。

前两个构造函数new Thread(c1)正在传递ThreadDemoCounter的实例，因此这两个线程将调用c1实例的ThreadDemoCounter.run()方法。

其他两个构造函数正在将A 方法参考传递给c1的incrementOnly()方法。这是一种有效的方法，因为它也是一种无验证方法。这两个线程将调用c1实例的ThreadDemoCounter.incrementOnly()方法。

总的来说，您将运行4个线程，其中两个执行run()方法，而其中两个执行incrementOnly()方法，所有这些方法都在ThreadDemoCounter的同一实例上，即c1。

fyi：该代码中没有lambda表达式。方法参考表达式不是lambda表达式。