Synchronized在多线程中的使用

同步多线程：当两个并发线程访问同一个对象object中的synchronized（this）同步代码块时，一段时间内只能有一个线程被执行，另一个必须等待当前线程执行完这个代码块以后才能执行改代码。

class Task{
    public int i = 0;
    public synchronized void changeI(){
        System.out.println("begin task");
        for(int j = 0; j < 5; j++){
            System.out.print(i + "--" + Thread.currentThread().getName()+"  ");
            i++;
        }
        System.out.println("\nend task");
    }
}

class ThreadA extends Thread{
    Task task;
    public ThreadA(Task task) {
        // TODO Auto-generated constructor stub
        this.task = task;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        task.changeI();
    }
}

客户端执行类

public class SyschronizedTest {
    public static void main(String[] args){
        Task task = new Task();
        ThreadA a = new ThreadA(task);
        ThreadA b = new ThreadA(task);
        a.start();
        b.start();
    }
}

运行结果

用同步代码块解决同步方法的弊端

class TaskProblem{
    private String getData1;
    private String getData2;
    public void doLongTimeTask() throws InterruptedException{
        System.out.println("begin task");
        Thread.sleep(3000);
        String PrivateGetData1 = "长时间处理任务后从远程返回到的值1 threadName = " + Thread.currentThread().getName();
        String PrivateGetData2 = "长时间处理任务后从远程返回到的值2 threadName = " + Thread.currentThread().getName();
        synchronized(this){
            getData1 = PrivateGetData1;
            getData2 = PrivateGetData2;
        }
        System.out.println(getData1);
        System.out.println(getData2);
        System.out.println("end task");

    }
}

class ThreadProblem extends Thread{
    TaskProblem task;
    public ThreadProblem(TaskProblem task) {
        // TODO Auto-generated constructor stub
        this.task = task;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        try {
            task.doLongTimeTask();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

public class SynchronizedTestProblem {
    public static void main(String[] args){
        TaskProblem task = new TaskProblem();
        ThreadProblem a = new ThreadProblem(task);
        ThreadProblem b = new ThreadProblem(task);
        a.start();
        b.start();

    }
}

第一次运行：

第二次运行：

总结：当一个线程访问Object的一个synchronized同步代码块时，另一个线程仍然可以访问该object对象的非synchronized（this）同步代码块。

一半异步，一半同步

下面这个程序用来说明：不在synchronized块中就是异步执行，在synchronized块中的就是同步执行

class TaskAsync{
    public void doLongTimeTask(){
        for(int i = 0; i < 5; i++){
            System.out.println("nosynchronized threadName = " + Thread.currentThread().getName() + " i=" + (i+1));
        }
        System.out.println("");
        synchronized (this) {
        for(int i = 0;i < 5; i++){
            System.out.println("synchronized threadName=" + Thread.currentThread().getName() + " i=" + (i+1));
        }
        }
    }
}

class ThreadAsync extends Thread{
    TaskAsync task;
    public ThreadAsync(TaskAsync task) {
        // TODO Auto-generated constructor stub
        this.task = task;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        task.doLongTimeTask();
    }
}

public class SynchronizedTestAsync {
    public static void main(String[] args){
        TaskAsync task = new TaskAsync();
        ThreadAsync a = new ThreadAsync(task);
        ThreadAsync b = new ThreadAsync(task);
        a.start();
        b.start();
    }
}

运行结果：

synchronized代码块之间的同步性
在使用同步synchronized(this)代码块时需要注意的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对同一个object中所有其他synchronized(this)同步代码块的访问将被阻塞，这说明synchronized使用的“对象监视器”是一个。

class ObjectService{
    public void serviceMethodA() throws InterruptedException{
        synchronized(this){
            System.out.println("A begin time=" + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("A end end=" + System.currentTimeMillis());
        }
    }
    public void serviceMethodB(){
        synchronized(this){
            System.out.println("B begin time=" + System.currentTimeMillis());
            System.out.println("B end time=" + System.currentTimeMillis());
        }
    }
}

class ThreadObjectA extends Thread{
    private ObjectService service;
    public ThreadObjectA(ObjectService service) {
        // TODO Auto-generated constructor stub
        this.service = service;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        try {
            service.serviceMethodA();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class ThreadObjectB extends Thread{
    private ObjectService service;
    public ThreadObjectB(ObjectService service) {
        // TODO Auto-generated constructor stub
        this.service = service;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        service.serviceMethodB();
    }
}

运行结果

验证同步synchronized(this)代码块是锁定当前对象的
和synchronized方法一样，synchronized(this)代码块也是锁定当前对象的。