Javase-Concurrency

当多个线程同时读写一个对象的数据时就可能产生竞争，java提供了几种方法防止竞争。

1.synchronized方法。当一个对象调用某个synchronized方法时，若其他线程也想调用该对象的synchronized方法时，则会阻塞。

2.Lock对象。

3.synchronized子句。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class SynchronizedTest {
    
    static class Run implements Runnable
    {
        private IncreaseThree it;
        private int times;
        
        public Run(IncreaseThree it, int times)
        {
            this.it = it;
            this.times = times;
        }

        @Override
        public void run() {
            for (int i = 0; i < times; i++)
            {
                it.increaseThree();
            }
        }
        
    }
    
    public static void main(String[] args) throws InterruptedException
    {
        IncreaseThree it = new IncreaseThree();
        //it = new SynchronizedIncrease1();
        //it = new SynchronizedIncrease2();
        //it = new LockIncreaseThree();
        
        ExecutorService es = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++)
            es.execute(new Run(it, 100));
        
        //等待子线程结束
        TimeUnit.SECONDS.sleep(1);
        
        if (it.getValue() != 3 * 10 * 100)
        {
            System.out.println("出现竞争:value=" + it.getValue());
        }
        else
        {
            System.out.println("未出现竞争:value=" + it.getValue());
        }
    }

}

class IncreaseThree
{
    protected int value = 0;
    
    protected void increaseThree()
    {
        value++;
        //切换线程,增强效果
        Thread.yield();
        value++;
        Thread.yield();
        value++;
        Thread.yield();
    }
    
    public int getValue()
    {
        return value;
    }
}

class SynchronizedIncrease1 extends IncreaseThree
{
    public void increaseThree()
    {
        synchronized(this)
        {
            value++;
            //切换线程,增强效果
            Thread.yield();
            value++;
            Thread.yield();
            value++;
            Thread.yield();
        }
    }
}

class SynchronizedIncrease2 extends IncreaseThree
{
    public synchronized void increaseThree()
    {
        value++;
        //切换线程,增强效果
        Thread.yield();
        value++;
        Thread.yield();
        value++;
        Thread.yield();
    }
}

class LockIncreaseThree extends IncreaseThree
{
    Lock lock = new ReentrantLock();
    public void increaseThree()
    {
        lock.lock();
        try
        {
        value++;
        //切换线程,增强效果
        Thread.yield();
        value++;
        Thread.yield();
        value++;
        Thread.yield();
        }finally
        {
            lock.unlock();
        }
    }
    
}

使用IncreaseThree对象时，会发生竞争运行一次就发生竞争：

出现竞争:value=2997

使用SynchronizedIncrease1, SynchronizedIncrease2, LockIncreaseThree对象时，运行多次也不会出现竞争。