Java高并发程序设计学习笔记（一）一些基本概念

 

并发级别：阻塞、无饥饿、无障碍、无锁、无等待

阻塞：一个线程是阻塞的，就是必须等待其他线程释放资源。使用synchronization关键字，或者在重入锁时就能得到阻塞线程。（悲观锁）

无饥饿：有优先级线程时，线程调度会优先满足优先级高的线程。。非公平锁的情况下系统允许高优先级的线程插队，可能导致低优先级的线程产生饥饿。

无障碍：最弱的非阻塞调度。可以同时进入临界区，但是如果检测到其它线程也在修改资源，就会对自己所做的修改进行回滚。（乐观锁），可能存在的问题，所有线程都在临界区不断的回滚。

一种无障碍实现方式，依赖一个“一致性标记”，线程在操作之前先读取并保存这个标记，在操作完成之后，再次读取。检查标记是否被修改。如果一致说明没有资源访问冲突。否则与其他写线程冲突，需要重试。任何对资源有修改操作的线程在修改数据前都需要更新这个标记。

无锁：无锁的并行都是无障碍的。无锁的情况下所有的线程都能尝试对临界区进行访问，但是，无锁的并发保证必然有一个线程能在有限步内完成操作离开临界区。

无锁的调用中可能会包含一个无穷循环，循环内线程会不断的尝试修改共享变量，没有冲突->修改成功->退出。否则继续尝试，总会有一个线程胜出。

无等待：在无锁的基础上更进一步，要求所有的线程都必须在有限步内完成，不会引起饥饿。进一步细分根据循环次数（有界无等待和线程无关等待）

 

JMM的关键技术：原子性，可见性和有序性

原子性：一个操作是不可中断的。即使多线程一起执行，一个操作一旦开始就不会被其他线程干扰。

可见性：一个线程修改了某一个共享变量的值，其他线程是否能立即直到这个修改。

有序性：一个线程内而言，代码总是从先往后依次执行。但是在并发时，程序的执行可能会出现乱序。

 

 

Happen-Before原则

重排的原则

1.程序顺序原则：一个线程内保证语义的串行性

2.volatile规则：volatile变量的写，先发生于读，这保证了volatile变量的可见性

3.锁规则：解锁（ulock）必然发生在随后的加锁（lock)前

4.传递性：A先于B,B先于C,那么A必然先于C

5.线程的start(）方法先于它的每一个动作

6.线程的所有操作先于线程的终结（Thread.jion）

7.线程的中断（interrupt）先于被中断线程的代码

8.对象的构造函数执行、结束先于finalize()方法

 

 

线程中断：

线程中断不会使线程立即退出，而是给线程发送一个通知，由目标线程自行决定。

以下三个方法：

public void Thread.interrupt() // 中断线程
public boolean Thread.isInterrupt() // 判断线程是否被中断
public static boolean Thread.inerrupt() //判断是否被中断，并清除当前中断状态

等待和通知

wait()方法和notif()方法。这两个方法并不在Thread类中，而是在输出objec类中。意味着任何对象都可以调用这两个方法。

public final void wait() throws Interuptedexception
public final native void notify()

例如线程A中调用了obj.wait()方法，那么线程A就会停止继续执行。直到其他线程调用了obj.notify()方法。这时obj对象就成为了两个线程之间的通信手段。

 

工作方式：

一个线程调用了obj.wait()方法后，就会进入object对象的等待队列。这个等待队列中，可能会有多个线程，因为系统运行多个线程同时等待某一个对象。当obj.notify()被调用时，它就会从这个等待队列中随机选一个线程唤醒，这个选择是完全随机的。与之类似的有notifyAl（）。会唤醒这个等待队列中的所有等待线程。

obj.wait()方法并不是可以随便调用，必须包含在对应的synchronization语句中。无论是wait()还是notify()都需要首先获取目标对象的一个监视器。一个对象只有一个监视器，必须得由其他对象释放后当前线程才能获得。

public class SimpleWN {
    final static Object object = new Object();
    public static class T1 extends Thread {
        public void run() {
           synchronized(object) {
            try{
                System.out.println(System.currentTimeMillis() + "T1 start!");
                object.wait();
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
           System.out.println(System.currentTimeMillis() + ":T1 end!")
        }
    } 
    }
    public static class T2 extends Thread{
    public void run() {
            synchronized(object) {
                System.out.println(System.currentTimeMillis() + "T2 start!");
                object.notify();
                System.out.println(Syetem.currentTimeMillis() + "T2 end");
                try{
                    Thread.sleep(2000);
                }catch(InterruptedException e) {
                }
            }
        }
    }      
    public static void main(String[] args) {
        Thread t1 = new T1();
        Thread t2 = new T2();
        t1.start();
        t2.start();
        
    }
}
执行结果会是：
T1 start!
T1 wait for object
T2 start! notify one thread
T2 end
T1 end

obj.wait()和thread.slee()都可以使线程等待，wait可以被唤醒，并且会释放目标对象得锁，sleep不会释放任何资源。

 

挂起suspend和继续执行resume

已不推荐，suspend（）在导致线程暂停的同时，并不会释放任何资源。此时，任何想要访问被它暂用的锁时都会被牵连。直到对应线程执行resume。但是如果resume意外的在suspend之前执行了，挂起的线程可能会被永久挂起。

 

比较靠谱的方法是通过wait()和notify()方法来设置标志位判断线程是否被挂起

如下代码

public class GoodSuspend {
    public static Object u = new Object();

    public static class ChangeObejctThread extends Thread{
        volatile boolean suspendme = false;
        public void suspendMe() {
            suspendme = true;
        }

        public void resumeMe() {
            suspendme = false;
            synchronized (this) {
                notify();
            }
        }

        @Override
        public void run() {
            while(true) {
                synchronized (this) {
                    while(suspendme) {
                        try {
                            wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                synchronized (u) {
                    System.out.println("in ChangeObjectThread");
                }
                Thread.yield();
            }
        }
    }
    public static class ReadObejctThread extends Thread {
        @Override
        public void run() {
            while(true) {
                synchronized (u) {
                    System.out.println("in ReadObjectThread");
                }
                Thread.yield();
            }
        }
    }
}

等待线程结束（join）和谦让（yield）

join（）和 join 没有参数表示无限等待，有参数表示等待最大时间。join()的本质是让调用线程的wait()在当前线程实例上。yield方法是让当前线程让出CPU，进入cpu资源的争夺，并不是停止执行。

 

volatile关键字与Java内存模型（JMM）

用volatile申明一个变量时，就等于告诉虚拟机，这个变量极有可能被某些程序或者线程修改。为了确保变量修改后，应用程序范围内的所有线程都能“看到”这个改动，虚拟机需要保证其的可见性。

 

volatoile关键字可以在一定程度上保证原子性，但是不能代替锁，也无法保证一些复合操作的原子性。

如下：

static volatile int i = 0;
public static class PlusTask implements Runnable {
    public void run() {
        for(int k = 0; k < 10000; k++) {
            i++;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[10];
        for(int i = 0; i < 10; i++) {
            thread[i] = new Thread(new PlusTask());
            thread[i].start();
            
        }
        for(int i = 0; i < 10; i++) {
            thread[i].join();
        }
        System.out.println(i);
    }
}

 

执行上诉代码，如果第6行i++是原子性的，那么最终的应该是100000，但实际上上诉代码的输出总会小于100000；

此外，volatile也能保证数据的可见性和有序性。

 

守护线程（Daemon），系统的守护者，在后台完成一些系统性的服务，比如垃圾回收线程、JIT线程就可以理解为守护线程。与之对应的是用户线程，用户线程可以认为是系统的工作线程。如果用户线程全部结束，守护线程需要守护的对象也就不存在了，相应也会结束，只有守护线程时，Java虚拟机会自然退出。

 

synchronized关键字。作用是实现线程间的同步。对同步的代码加锁，使得每一次，只有一个线程进入同步块，从而保证线程间的安全性。

三种用法：

1.指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁

2.直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

3.直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

对象加锁：

public class SynchronizedTest extends Thread{
    static SynchronizedTest instance = new SynchronizedTest();
    static int i = 0;
    @Override
    public void run() {
        for (int j = 0; j < 10000; j++) {
            synchronized (instance) {     //加锁对象
                i++;
            }
        }
    }
}

实例方法加锁

public class SynchronizedTest extends Thread{
    static SynchronizedTest instance = new SynchronizedTest();
    static int i = 0;
    public synchronized void increase() {   //给实例方法加锁
        i++;
    }
    @Override
    public void run() {
        for (int j = 0; j < 10000; j++) {
            increase();   //给实例方法加锁
        }
    }
    public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(instance);
    Thread t2 = new Thread(instance);
    t1.start(); t2.start();‘’‘’‘’‘’‘’‘
    t1.join(); t2.join();
    }
}

静态方法加锁（注意这里没有静态对象）

public class SynchronizedTest extends Thread{
    static int i = 0;
    public static synchronized void increase() {
        i++;
    }
    @Override
    public void run() {
        for (int j = 0; j < 10000; j++) {
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(new SynchronizedTest());
    Thread t2 = new Thread(new SynchronizedTest());
    t1.start(); t2.start();
    t1.join(); t2.join();
    }
}