Java多线程学习笔记(四) 使用ReentrantLock实现同步

1. 测试1

1.1 MyService

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {
    private Lock lock = new ReentrantLock();

    public void testMethod(){
        lock.lock();

        for (int i = 0; i < 3; i++){
            System.out.println("ThreatName = " + Thread.currentThread().getName() +
                    " " + i);
        }

        lock.unlock();
    }
}

1.2 MyThread

public class MyThread extends Thread {

    private MyService service;

    public MyThread(MyService service){
        super();
        this.service = service;
    }

    @Override
    public void run(){
        service.testMethod();
    }
}

1.3 Test

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

        MyService service = new MyService();

        MyThread t1 = new MyThread(service);
        MyThread t2 = new MyThread(service);
        MyThread t3 = new MyThread(service);

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

1.4 运行结果

ThreatName = Thread-0 0
ThreatName = Thread-0 1
ThreatName = Thread-0 2
ThreatName = Thread-2 0
ThreatName = Thread-2 1
ThreatName = Thread-2 2
ThreatName = Thread-1 0
ThreatName = Thread-1 1
ThreatName = Thread-1 2

2. 测试2

2.1 MyService

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {

    private Lock lock = new ReentrantLock();

    public void methodA(){
        try {
            lock.lock();
            System.out.println("methodA begin, ThreadName = " + Thread.currentThread().getName());

            Thread.sleep(3000);

            System.out.println("methodA end  , ThreadName = " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void methodB(){
        try {
            lock.lock();
            System.out.println("methodB begin, ThreadName = " + Thread.currentThread().getName());

            Thread.sleep(3000);

            System.out.println("methodB end  , ThreadName = " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

2.2 ThreadA

public class ThreadA extends Thread{
    private MyService service;

    public ThreadA(MyService service){
        super();
        this.service = service;
    }

    @Override
    public void run(){
        service.methodA();
    }
}

2.3 ThreadAA

public class ThreadAA extends Thread{
    private MyService service;

    public ThreadAA(MyService service){
        super();
        this.service = service;
    }

    @Override
    public void run(){
        service.methodA();
    }
}

2.4 ThreadB

public class ThreadB extends Thread{
    private MyService service;

    public ThreadB(MyService service){
        super();
        this.service = service;
    }

    @Override
    public void run(){
        service.methodB();
    }
}

2.5 Test

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();

        //A thread
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

        //AA thread
        ThreadAA aa = new ThreadAA(service);
        aa.setName("AA");
        aa.start();
        Thread.sleep(1000);

        //B thread
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
    }
}

2.6 运行结果

methodA begin, ThreadName = A
methodA end  , ThreadName = A
methodA begin, ThreadName = AA
methodA end  , ThreadName = AA
methodB begin, ThreadName = B
methodB end  , ThreadName = B

调用lock()，线程就有了对象监视器，其他的线程只能等待锁再次释放，效果和synchronized一样，线程还是顺序执行的。