Java 是否锁定了 C 中的 PThread_Mutex？

Question

I wrote the exact same program in C and in Java, where two threads increment a global counter. To ensure exclusivity of the access on the counter in C a pthread_mutex_t is used, while in Java synchronized(lock) :

The C version:

  1 #include <stdio.h>
  2 #include <pthread.h>
  3 
  4 static volatile int global;
  5 static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
  6 
  7 static void *run(void *arg) {
  8     int nLoop = *((int *) arg);
  9     int localValue;
 10 
 11 
 12 
 13 
 14 
 15     for (int j = 0; j < nLoop; j++) {
 16         pthread_mutex_lock(&mtx);
 17         localValue = global;
 18         localValue = localValue + 1;
 19         global     = localValue;
 20         pthread_mutex_unlock(&mtx);
 21     }
 22     return NULL;
 23 }
 24 
 25 int main() {
 26     pthread_t t1, t2;
 27     int nLoop = 100000;
 28 
 29     int i = 0;
 30     while (i<10) {
 31         global = 0;
 32         pthread_create(&t1, NULL, run, &nLoop);
 33         pthread_create(&t2, NULL, run, &nLoop);
 34 
 35         pthread_join(t1, NULL); pthread_join(t2, NULL);
 36         printf("global: %d\n", global);
 37         i++;
 38     }
 39     return 0;
 40 }

The Java version:

  1 public class ThreadIncr {
  2 
  3 
  4     static int global;
  5     private final static Object lock = new Object();
  6 
  7     static class R implements Runnable {
  8         int nLoop;
  9         int localValue;
 10 
 11         public R(int nLoop) { this.nLoop = nLoop; }
 12 
 13         @Override
 14         public void run() {
 15             for(int j = 0; j<this.nLoop; j++) {
 16                 synchronized(lock) {
 17                     localValue = global;
 18                     localValue = localValue + 1;
 19                     global = localValue;
 20                 }
 21             }
 22         }
 23     }
 24 
 25     public static void main(String[] args) throws InterruptedException {
 26         Thread t1, t2;
 27         int nLoop = 100000;
 28 
 29         int i = 0;
 30         while (i < 10) {
 31             global = 0;
 32             t1 = new Thread(new R(nLoop));
 33             t2 = new Thread(new R(nLoop));
 34             t1.start(); t2.start();
 35             t1.join();  t2.join();
 36             System.out.println("global: " + global);
 37             i++;
 38         }
 39     }
 40 }

So basically the lock of Java is the mutex in C?

Answer 1

In Java "synchronized(lock)" means that so called monitor lock is used. That monitor lock provides mutual exclusion ( link ). So, it provides the same functionality as mutex in C.