java syslog 协议通信

一、 多线程锁synchronized

1. 概念说明：synchronized是java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能保证在同一时刻最多只有一个线程执行该段代码。
2. 使用方式：
   a. 修饰代码块：注意在锁的时候，一定要保证是同一个对象

/**
 * 不使用synchronized加锁的情况下，线程A,B交替执行
 * 可能输出的结果:
 * Thread B print 0
 * Thread B print 1
 * Thread B print 2
 * Thread A print 0
 * Thread B print 3
 * Thread A print 1
 * Thread B print 4
 * Thread A print 2
 * Thread A print 3
 * Thread A print 4
 */
public class SyncDemo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " print " + i);
        }
    }

    public static void main(String[] args) {
        SyncDemo syncDemo = new SyncDemo();
        Thread threadA = new Thread(syncDemo, "Thread A");
        Thread threadB = new Thread(syncDemo, "Thread B");
        threadA.start();
        threadB.start();
    }
}

/**
 * 使用synchronized加锁的情况下，线程A和线程B必须排队等待其中一个线程执行完成释放锁后才能继续执行
 * 可能输出的结果:
 * Thread A print 0
 * Thread A print 1
 * Thread A print 2
 * Thread A print 3
 * Thread A print 4
 * Thread B print 0
 * Thread B print 1
 * Thread B print 2
 * Thread B print 3
 * Thread B print 4
 */
public class SyncDemo implements Runnable {
    @Override
    public void run() {
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " print " + i);
            }
        }
    }

    public static void main(String[] args) {
        SyncDemo syncDemo = new SyncDemo();
        Thread threadA = new Thread(syncDemo, "Thread A");
        Thread threadB = new Thread(syncDemo, "Thread B");
        threadA.start();
        threadB.start();
        
        // 稍微改动一下,此时为两个不同对象，则无法保证线程C和线程D必须等待对方执行完成才继续执行
        Thread threadC = new Thread(new SyncDemo(), "Thread C");
        Thread threadD = new Thread(new SyncDemo(), "Thread D");
        threadC.start();
        threadD.start();
    }
}

b. 修饰普通方法:

/**
 * 使用synchronized修饰普通方法，线程A和线程B必须排队等待其中一个线程执行完成释放锁后才能继续执行
 * 可能输出的结果:
 * Thread A print 0
 * Thread A print 1
 * Thread A print 2
 * Thread A print 3
 * Thread A print 4
 * Thread B print 0
 * Thread B print 1
 * Thread B print 2
 * Thread B print 3
 * Thread B print 4
 */
public class SyncDemo implements Runnable {
    @Override
    public synchronized void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " print " + i);
        }
    }

    public static void main(String[] args) {
        SyncDemo syncDemo = new SyncDemo();
        Thread threadA = new Thread(syncDemo, "Thread A");
        Thread threadB = new Thread(syncDemo, "Thread B");
        threadA.start();
        threadB.start();
    }
}

c. 修饰静态方法：上面的演示了，当创建两个不同的对象时，添加synchronized块或者是在方法上面添加synchronized，两个不同对象是彼此独立的锁，但是使用在静态方法上面使用synchronized，两个对象却保持了同步，这是因为run中调用的静态方法，而静态方法是属于同一个类的，所有两个对象相当与持有了同一把锁。

/**
 * synchronized修饰静态方法，当两个不同的对象同时启动静态方法，因为静态方法是同一个方法，
 * 无论你创建多少个类对象，静态方法都是同一个，则线程A和线程B在调用静态方法时，都持有同一
 * 把锁
 * 可能输出的结果:
 * Thread A print 0
 * Thread A print 1
 * Thread A print 2
 * Thread A print 3
 * Thread A print 4
 * Thread B print 0
 * Thread B print 1
 * Thread B print 2
 * Thread B print 3
 * Thread B print 4
 */
public class SyncDemo implements Runnable {
    @Override
    public void run() {
        method();
    }

    public synchronized static void method() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " print " + i);
        }
    }

    public static void main(String[] args) {
        // 此时线程A和线程B为不同对象的线程
        Thread threadA = new Thread(new SyncDemo(), "Thread A");
        Thread threadB = new Thread(new SyncDemo(), "Thread B");
        threadA.start();
        threadB.start();
    }
}

二. 多线程之volatile

1. 概念：volatile关键字修饰一个共享变量(类的成员变量、类的静态成员变量)，则会具备两层意义：
   a. 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，则新值对其他线程来说是立即可见的。
   b. 禁止指令进行重排序

/**
 * 使用volatile终止线程
 */
public class VolatileDemo implements Runnable {
    // 如果不是用volatile关键字，可以能导致线程死锁，永远无法终止线程
    private static volatile boolean flag = false;

    @Override
    public void run() {
        while (!flag) {
            System.out.println(Thread.currentThread().getName() + "线程被中断");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new VolatileDemo(), "Thread A ");
        thread.start();
        TimeUnit.SECONDS.sleep(5);
        flag = true;
    }
}

1. volatile关键字无法保证原子性，仅仅只能保证可见性：

/**
 * volatile关键字无法保证操作的原子性，只能保证可见性
 *   结果始终都会小于10000
 */
public class VolatileDemo2 {
    private volatile int num = 0;

    public void increase() {
        num++;
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(10);
        final VolatileDemo2 volatileDemo = new VolatileDemo2();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 1000; j++) {
                        volatileDemo.increase();
                    }
                } finally {
                    countDownLatch.countDown();
                }
            }).start();

        }
        // 需要测试结果，需要让所有的线程全部执行完成
        countDownLatch.await();
        System.out.println(volatileDemo.num);
    }
}