多线程并发详解

public class StartThread extends Thread{

	//线程入口点
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("listen music");
		}
	}
	public static void main(String[] args) {
		//创建子类对象
		StartThread st=new StartThread();
		//调用start方法
		st.start();//开启新线程交于cpu决定执行顺序
		for(int i=0;i<10;i++) {
			System.out.println("coding");
		}
	}
}

public class StartRun implements Runnable{

	//线程入口点
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("listen music");
		}
	}
	public static void main(String[] args) {
		//创建实现类对象
		StartRun st=new StartRun();
		//创建代理类对象
　　　　　　//启动 MyThread，需要首先实例化一个 Thread，并传入自己的 MyThread 实例：

		Thread t=new Thread(st); 　　　　　　　　　　
　　　　　//事实上，当传入一个 Runnable target 参数给 Thread 后，Thread 的 run()方法就会调用target.run()
		//调用start方法
		t.start();//开启新线程交于cpu决定执行顺序

		//匿名法
//		new Thread(new StartRun()).start();
		for(int i=0;i<10;i++) {
			System.out.println("coding");
		}
	}
}

// 创建线程池
 ExecutorService threadPool = Executors.newFixedThreadPool(10);
 while(true) {
     threadPool.execute(new Runnable() { // 提交多个线程任务，并执行
         @Override
         public void run() {
             System.out.println(Thread.currentThread().getName() + " is running ..");
             try {
                 Thread.sleep(3000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
      });
   } 
}                

　线程池应用场合

　　• 对性能要求苛刻

　　• 接受突发性的大量请求

 ScheduledExecutorService scheduledThreadPool= Executors.newScheduledThreadPool(3); 
 scheduledThreadPool.schedule(new Runnable(){ 
     @Override 
     public void run() {
         System.out.println("延迟三秒");
     }
 }, 3, TimeUnit.SECONDS);
scheduledThreadPool.scheduleAtFixedRate(new Runnable(){ 
     @Override 
     public void run() {
         System.out.println("延迟 1 秒后每三秒执行一次");
     }
 },1,3,TimeUnit.SECONDS);

　3.2 就绪状态（RUNNABLE）

　　• 当线程对象调用了 start()方法之后，该线程处于就绪状态。Java 虚拟机会为其创建方法调用栈和程序计数器，等待调度运行。

　　• 处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU

　3.3 运行状态（RUNNING）

　　• 如果处于就绪状态的线程获得了 CPU，开始执行 run()方法的线程执行体，则该线程处于运行状态。 

　　　　•  正常结束 ： run()或 call()方法执行完成，线程正常运行结束。

　　　　•  异常结束 ：线程抛出一个未捕获的 Exception 或 Error。

public class ThreadSafe extends Thread {
    public volatile boolean exit = false; 
    public void run() { 
        while (!exit){
         //do something
        }
    } 
}

　　定义了一个退出标志 exit，当 exit 为 true 时，while 循环退出，exit 的默认值为 false.在定义 exit时，使用了一个 Java 关键字 volatile(保证可见性但是不保证原子性，线程不安全)，这个关键字的目的是使 exit 同步，也就是说在同一时刻只能由一个线程来修改 exit 的值。

　4.3 Interrupt 方法结束线程

　　4.3.2 线程未处于阻塞状态：使用 isInterrupted()判断线程的中断标志来退出循环。当使用interrupt()方法时，中断标志就会置 true，和使用自定义的标志来控制循环是一样的道理。

 public class ThreadSafe extends Thread {
     public void run() { 
         while (!isInterrupted()){ //非阻塞过程中通过判断中断标志来退出
             try{
                 Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出
             }catch(InterruptedException e){
                 e.printStackTrace();
                 break;//捕获到异常之后，执行 break 跳出循环
             }
         }
     } 
}

　4.4 stop 方法终止线程（线程不安全）

　　　线程的优先级用数字表示，范围从1到10：

　　　　• Thread.MIN_PRIORITY = 1

　　　　• Thread.NORM_PRIORITY = 5

　　　使用下述方法获得或设置线程对象的优先级。

　　　　• void setPriority(int newPriority);

　5.2 线程启动（start）

　　　线程由新生态进入就绪态，等待cpu调度运行。

　5.3 线程等待（wait）

　　　调用该方法的线程进入 WAITING 状态，只有等待另外线程的通知或被中断才会返回，需要注意的是调用 wait()方法后，会释放对象的锁。因此，wait 方法一般用在同步方法或同步代码块中。

　5.4  线程睡眠（sleep）

　　　sleep 导致当前线程休眠，与 wait 方法不同的是 sleep 不会释放当前占有的锁,sleep(long)会导致线程进入 TIMED-WATING 状态，而 wait()方法会导致当前线程进入 WATING 状态。

　5.5 线程让步（yield）

System.out.println(Thread.currentThread().getName() + "线程运行开始!");
 Thread6 thread1 = new Thread6();
 thread1.setName("线程 B");
 thread1.join();
System.out.println("这时 thread1 执行完毕之后才能执行主线程");

　5.8 设置为守护线程（setDaemon）

　　　• 创建后台线程的线程结束时，后台线程也随之消亡

　6.7 引起线程上下文切换的原因

　　2. 优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。

　　4. 在 Daemon 线程中产生的新线程也是 Daemon 的。

　　5. 线程则是 JVM 级别的，以 Tomcat 为例，如果你在 Web 应用中启动一个线程，这个线程的生命周期并不会和 Web 应用程序保持同步。也就是说，即使你停止了 Web 应用，这个线程依旧是活跃的。

　　6. example: 垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的Thread,程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是 JVM 上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。

　　同步锁：当多个线程同时访问同一个数据时，很容易出现问题。为了避免这种情况出现，我们要保证线程同步互斥，就是指并发执行的多个线程，在同一时间内只允许一个线程访问共享数据。 Java 中可以使用 synchronized 关键字来取得一个对象的同步锁。

　8.2 Synchronized 同步锁

　　　4. OnDeck 线程获取到锁资源后会变为 Owner 线程，而没有得到锁资源的仍然停留在 EntryList中。如果 Owner 线程被 wait 方法阻塞，则转移到 WaitSet 队列中，直到某个时刻通过 notify或者 notifyAll 唤醒，会重新进去 EntryList 中。

　　　5. 处于 ContentionList、EntryList、WaitSet 中的线程都处于阻塞状态，该阻塞是由操作系统来完成的（Linux 内核下采用 pthread_mutex_lock 内核函数实现的）。

　　　7. 每个对象都有个 monitor 对象，加锁就是在竞争 monitor 对象，代码块加锁是在前后分别加上 monitorenter 和 monitorexit 指令来实现的，方法加锁是通过一个标记位来判断的

　　　8. synchronized 是一个重量级操作，需要调用操作系统相关接口，性能是低效的，有可能给线程加锁消耗的时间比有用操作消耗的时间更多。

　　　10. 锁可以从偏向锁升级到轻量级锁，再升级到重量级锁。这种升级过程叫做锁膨胀；

　　• ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义， 但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。

　　线程同步的缺点

　　（1）对变量的写操作不依赖于当前值（比如 i++），或者说是单纯的变量赋值（boolean flag = true）。

 　　均是java.lang.Object类的方法都只能在同步方法或者同步代码块中使用，否则会抛出异常

　10.2 两个线程之间共享数据

public class MyData {
    private int j=0;
    public synchronized void add(){
        j++;
        System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);
    }
    public synchronized void dec(){
        j--;
        System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);
    }
    public int getData(){
        return j;
    }     
}
public class AddRunnable implements Runnable{
    MyData data;
    public AddRunnable(MyData data){
        this.data= data;
    }
    public void run() {
        data.add();
    } 
}
public class DecRunnable implements Runnable {
    MyData data;
    public DecRunnable(MyData data){
        this.data = data;
    }
    public void run() {
        data.dec();
    } 
}
public static void main(String[] args) {
    MyData data = new MyData();
    Runnable add = new AddRunnable(data);
    Runnable dec = new DecRunnable(data);
    for(int i=0;i<2;i++){
        new Thread(add).start();
        new Thread(dec).start();
    }    
}

public class MyData {
    private int j=0;
    public synchronized void add(){
        j++;
        System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);
    }
    public synchronized void dec(){
        j--;
        System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);
    }
    public int getData(){
        return j;
    } 
}
public class TestThread {
    public static void main(String[] args) {
        final MyData data = new MyData();
        for(int i=0;i<2;i++){
            new Thread(new Runnable(){
                public void run() {
                    data.add();
                }
            }).start();
            new Thread(new Runnable(){
                public void run() {
                    data.dec(); 
                }
            }).start();
        }
    } 
}

 使用场景：最常见的 ThreadLocal 使用场景为 用来解决 数据库连接、Session 管理等。

private static final ThreadLocal threadSession = new ThreadLocal(); 
public static Session getSession() throws InfrastructureException { 
    Session s = (Session) threadSession.get(); 
    try { 
        if (s == null) { 
            s = getSessionFactory().openSession(); 
            threadSession.set(s); 
        } 
    } catch (HibernateException ex) { 
        throw new InfrastructureException(ex); 
    } 
    return s; 
}

　12.1 抢占式调度：

　12.2 协同式调度

　12.3 JVM 的线程调度实现（抢占式调度） 

　12.4 线程让出 cpu 的情况

　13.1 优先调度算法

　　1. 先来先服务调度算法（FCFS）：当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用 FCFS 算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机，特点是：算法比较简单，可以实现基本上的公平。

　13.2 高优先权优先调度算法 

　　1. 非抢占式优先权算法：在这种方式下，系统一旦把处理机分配给就绪队列中优先权最高的进程后，该进程便一直执行下去，直至完成；或因发生某事件使该进程放弃处理机时。这种调度算法主要用于批处理系统中；也可用于某些对实时性要求不严的实时系统中。 

　　(1) 如果作业的等待时间相同，则要求服务的时间愈短，其优先权愈高，因而该算法有利于短作业。

　　(3) 对于长作业，作业的优先级可以随等待时间的增加而提高，当其等待时间足够长时，其优先级便可升到很高，从而也可获得处理机。简言之，该算法既照顾了短作业，又考虑了作业到达的先后次序，不会使长作业长期得不到服务。因此，该算法实现了一种较好的折衷。当然，在利用该算法时，每要进行调度之前，都须先做响应比的计算，这会增加系统开销。

　13.4 基于时间片的轮转调度算法

　　2. 多级反馈队列调度算法：

　　　(1) 应设置多个就绪队列，并为各个队列赋予不同的优先级。第一个队列的优先级最高，第二个队列次之，其余各队列的优先权逐个降低。该算法赋予各个队列中进程执行时间片的大小也各不相同，在优先权愈高的队列中，为每个进程所规定的执行时间片就愈小。例如，第二个队列的时间片要比第一个队列的时间片长一倍，……，第 i+1 个队列的时间片要比第 i 个队列的时间片长一倍。