Java 多线程 --- 多线程的相关概念

背景: 操作系统 — 线程/进程 同步

Race Condition 问题

• 下面的代码会创建100个银行账户,每一个账户初始金额是1000. 然后不段的随机给另外一个账户转钱.
• 不管怎么转钱, 100个账户的总金额应该一直保持为10000.
• 但是有的输出结果总金额不到10000, 因为出现了对critical section资源竞争的问题

package SimpleThread;
import java.util.*;

public class Bank {
	private final double[] accounts;

	public Bank(int n, double initialBalance) {
		accounts = new double[n];
		Arrays.fill(accounts, initialBalance);
	}

	public void transfer(int from, int to, double amount) {
		if (accounts[from] < amount) return;
		System.out.print(Thread.currentThread());
		accounts[from] -= amount;
		System.out.printf(" %10.2f from %d to %d", amount, from, to);
		accounts[to] += amount;
		System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
	}
	
	public double getTotalBalance() {
		double sum = 0;
		
		for (double a : accounts)
		sum += a;
		
		return sum;
	}
	
	public int size() {
		return accounts.length;
	}
 }

package SimpleThread;
public class UnsynchBankTest {
	public static final int NACCOUNTS = 100;
	public static final double INITIAL_BALANCE = 1000;
	public static final double MAX_AMOUNT = 1000;
	public static final int DELAY = 10;
	
	public static void main(String[] args)
	{
		Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
		for (int i = 0; i < NACCOUNTS; i++) {
			int fromAccount = i;
			Runnable r = () -> {
				try{
					while (true) {
						int toAccount = (int) (bank.size() * Math.random());
						double amount = MAX_AMOUNT * Math.random();
						bank.transfer(fromAccount, toAccount, amount);
						Thread.sleep((int) (DELAY * Math.random()));
					}
				}
				catch (InterruptedException e) {
					
				}
			};
			Thread t = new Thread(r);
			t.start();
		}
	}
}

• 因为 accounts[to] += amount; 和 accounts[from] -= amount;不是原子操作, 也就是此行代码分为三条指令

• step1: 将accounts[i] 放入寄存器
• step2: 将amount增加或者减少
• step3: 将结果放回accounts[i]

• 假设线程1执行完前两步之后被打断, 线程2执行全部三个步骤, 然后线程1继续执行第三步, 则线程2的数据会被线程1的第三步覆盖

并发编程的性质 — 原子性, 可见性, 有序性

原子性

• 一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。比如上面的例子就没有保证原子性

• 注意: 原子操作 + 原子操作 != 原子操作
• 如下: 如果a是原子操作, b也是原子操作 但是 a + b 不是原子操作

a = 1
b = 2

• 在 Java 语言中, 除去 long 类型和double 类型, 剩下所有类型 (包括基础类型和引用类型) 的 写(write) 操作都是原子操作.

• 写入是原子操作: byte, boolean, short, char, float, int 和其他引用操作
• 写入不是原子操作: long, double

• 在 Java 语言中, 所有类型的读取操作都是原子操作

可见性

• 由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间）

• 工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存
• 主内存是共享内存区域，所有线程都可以访问.

• 线程对变量的操作（读取赋值等）必须在工作内存中进行

• 首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写会主内存
• 不能直接操作主内存中的变量，各个线程中的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成

• 当一个线程修改了共享变量的值时，其他线程能够立即得知这个修改, 这个就是可见性

有序性

• 当发生指令重排时, 线程就失去了有序性
• 在源代码顺序与程序执行顺序不一致的情况下, 就发生了指令重排序
• 编译器出于性能的考虑, 在其认为不影响程序正确性的情况下可能会对源代码顺序进行调整, 从而造成程序顺序与相应的源代码顺序不一致.

上下文切换 (Context Switch)

• 当线程切入和切出操作系统的时候需要保存和恢复相应的线程的进度信息(如程序运行到什么程度了,计算的中间结果以及执行到了哪条指令)
• 这个进度的信息被称为上下文 (Context). 切换的过程叫做上下文切换(Context Switch)
• 一个线程的生命周期状态在 Runnable 状态 与 非Runnable状态之 (包括Blocked, Waiting) 之间切换的过程就是一个上下文切换的过程

上下文切换的原因 包括主动切换和被动切换

• 主动切换的原因包括以下

• Thread.sleep
• Object.wait()
• Thread.yield()
• Thread.join()
• 等

• 被动切换的原因包括

• 线程的时间片用完
• 优先级低的线程被优先级高的线程切换
• Java虚拟机也会导致被动上下文切换, 因为垃圾回收器可能需要暂停所有线程才能完成垃圾回收

线程的一些故障 — 死锁, 活锁, 饥饿

死锁 (Deadlock)

• 死锁: 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程

• 死锁的发生条件:

• 当前进程或线程拥有其他进程或线程需要的资源
• 当前进程或线程等待其他进程或线程已拥有的资源
• 都不放弃自己拥有的资源,也就是不能被其他进程或线程剥夺，只能在使用完以后由自己释放

Example 1:

mutex m
function {
	lock(m) //成功拿到锁
	lock(m) //拿不到锁，因为已经被自己拿了，所以会无限等待下去
	//critical section
	unlock(m)
	unlock(m)
}

Example 2:

• task A成功拿到M1的锁，同时task B成功拿到M2的锁
• task A等待获取M2的锁，同时task B等待获取M1的锁

• task A只有获得M2的锁才能往下继续然后释放M1的锁
• task B只有获得M1的锁才能往下继续然后释放M2的锁

活锁(Livelock)

• 活锁是不同线程占用对方所需要的资源, 导致任何线程都无法继续向前运行, 但是没有一个线程处于block状态. 而每个线程一遍又一遍的不断尝试获取资源并不断消耗CPU资源.

Example 1:

• 一个系统可以运行的进程总量由process table有多少个entry决定.
• 如果一个process table满了会导致一个进程fork子进程失败. 而失败以后父进程不会进入阻塞状态, 而是等待一段时间后再次fork子进程.
• 假设一个系统有100个entry. 10个父进程需要各创建12个子进程, 当新创建90个进程之后, process table被占满. 而10个父进程会不断的重新fork子进程.

Example 2:

public class CommonResource {
    private Worker owner;

    public CommonResource (Worker d) {
        owner = d;
    }

    public Worker getOwner () {
        return owner;
    }

    public synchronized void setOwner (Worker d) {
        owner = d;
    }
}

public class Worker {
    private String name;
    private boolean active;

    public Worker (String name, boolean active) {
        this.name = name;
        this.active = active;
    }

    public String getName () {
        return name;
    }

    public boolean isActive () {
        return active;
    }

    public synchronized void work (CommonResource commonResource, Worker otherWorker) {
        while (active) {
            // wait for the resource to become available.
            if (commonResource.getOwner() != this) {
                try {
                    wait(10);
                } catch (InterruptedException e) {
                   //ignore
                }
                continue;
            }

            // If other worker is also active let it do it's work first
            if (otherWorker.isActive()) {
                System.out.println(getName() +
                            " : handover the resource to the worker " +
                                                       otherWorker.getName());
                commonResource.setOwner(otherWorker);
                continue;
            }

            //now use the commonResource
            System.out.println(getName() + ": working on the common resource");
            active = false;
            commonResource.setOwner(otherWorker);
        }
    }
}

public class Livelock {

    public static void main (String[] args) {
        final Worker worker1 = new Worker("Worker 1 ", true);
        final Worker worker2 = new Worker("Worker 2", true);

        final CommonResource s = new CommonResource(worker1);

        new Thread(() -> {
            worker1.work(s, worker2);
        }).start();

        new Thread(() -> {
            worker2.work(s, worker1);
        }).start();
    }
}
 

• 以上代码当两个线程都是active时, 会互相谦让对方, 然后不断重新尝试, 进入livelock

output:

Worker 1  : handing over the resource to the worker: Worker 2
Worker 2 : handing over the resource to the worker: Worker 1
Worker 1  : handing over the resource to the worker: Worker 2
Worker 2 : handing over the resource to the worker: Worker 1
Worker 1  : handing over the resource to the worker: Worker 2
Worker 2 : handing over the resource to the worker: Worker 1

死锁和活锁的区别

• 活锁和死锁非常的像, 都是线程互相持有自己所需要的资源导致程序不能正常往下运行
• 区别是死锁的线程会进入等待状态, 也就是block状态
• 而活锁的进程不会进入等待状态, 而是会不断的尝试运行, 不断的消耗CPU资源.

饥饿(Starvation)

• 是指一个可运行的进程尽管能继续执行，但被调度器无限期地忽视，而不能被调度执行的情况

Example:

• 如果进程按照优先级运行, 也就是先运行高优先级的进程
• 那么如果一直有新的高优先级的进程被创建, 则低优先级的进程永远不会被执行, 进入饥饿状态