Java笔记 - 线程与并行API

一、线程简介

1、线程与进程

     每个进程都具有独立的代码和数据空间，进程间的切换会有较大的开销。线程是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC）,线程切换的开销小。

          多进程：在操作系统中能同时运行多个任务（程序）

          多线程：在同一应用程序中有多个顺序流同时执行

2、线程的应用

二、线程状态控制

      线程具有创建、就绪、运行、阻塞、终止，五种状，详细的状态转换如下图所示：

                

1、线程的创建与启动

   JVM启动时会有一个由主方法所定义的线程，程序员可以通过实现 Runable接口的类 或 Thread类 的实例创建新的线程，每个线程对象都是通过方法run()来完成其操作，通过start()方法来启动一个线程。

（1）定义线程类实现Runable接口【建议】

       使用Runable接口可以更灵活的定义多线程，如：为多个线程提供共享的数据（线程同步问题），另外，在实现Runable接口的类的run方法定义中可以使用Thread的静态方法。

public class Main {
	public static void main(String args[]) {
		Runner1 r = new Runner1();
		Thread t = new Thread(r);

		t.start();//r.run()是方法调用，而非线程启动

		for(int i=0; i<100; i++) {
			System.out.println("Main Thread:------" + i);
		}
	}
}

//同一个Runable可以创建多个Thread
class Runner1 implements Runnable {
	public int a = 0;
	public void run() {//定义线程体
		for(int i=0; i<100; i++) {
			System.out.println("Runner1 :" + i);
		}
	}
}

（2）定义Thread的子类，并重写run()方法

public class Main {
	public static void main(String args[]) {

		Runner1 r = new Runner1();
		r.start();

		for(int i=0; i<100; i++) {
			System.out.println("Main Thread:------" + i);
		}
	}
}

//Thread类已经实现了Runable接口
class Runner1 extends Thread {
	public void run() {
		for(int i=0; i<100; i++) {
			System.out.println("Runner1 :" + i);
		}
	}
}

（3）如何关闭一个线程

public class Main {
	public static void main(String args[]){
		Runner r = new Runner();
       	Thread t = new Thread(r);
        t.start(); //线程启动

        for(int i=0;i<10;i++){
        	if(i%2==0 & i>0)
        		System.out.println("in thread main i=" + i);
        }
        System.out.println("Thread main is over");

        //stop()与interrupt()会立即关闭线程，造成正在打开的资源无法关闭，不建议使用
        r.shutDown();
    }
}
//设置flag标志位，表示线程是否关闭
class Runner implements Runnable {
  private boolean flag=true;

	public void run() {
		int i = 0;
		while (flag==true) {
			System.out.println(" " + i++);
		}
	}

  public void shutDown() {
		flag = false;
  }
}

2、线程的基本操作

    线程控制基本方法如下：

               

（1）线程优先级

        JAVA提供一个线程调度器来监视程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级决定调度那个线程来执行。线程的优先级用户数字表示，范围从1到10，线程的缺省优先级是5。

                  Thread.MIN_PRIORITY = 1
                   Thread.NORM_PRIORITY = 5
                   Thread.MAX_PRIORITY = 10

public class Main {
	public static void main(String[] args) {
		Thread t1 = new Thread(new T1());
		Thread t2 = new Thread(new T2());

		System.out.println(t1.getPriority()); //获取线程对象的优先级
		t1.setPriority(Thread.NORM_PRIORITY + 3);//设置线程对象的优先级
		t1.start();
		t2.start();
	}
}

class T1 implements Runnable {
	public void run() {
		for(int i=0; i<100; i++) {
			System.out.println("T1: " + i);
		}
	}
}

class T2 implements Runnable {
	public void run() {
		for(int i=0; i<100; i++) {
			System.out.println("------T2: " + i);
		}
	}
}

（2）线程wait与sleep方法

      wait是Object的方法，调用wait方法时必须锁定对象，wait时别的线程可以访问锁定的对象，wait需要notify或notifyALL方法唤醒。

      sleep是Thread静态方法，sleep时别的方法不能访问锁定的对象，sleep方法等睡眠时间到了，可以自己苏醒。

import java.util.*;
public class Main {
  public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();//每隔一秒输出一次时间

    try {
    	//在未继承Thread类的方法在可以调用Thread的静态方法sleep暂停进程
    	Thread.sleep(10000);
    	} catch (InterruptedException e) {
    		e.printStackTrace();
    	}//主线程等待10s

    thread.interrupt();//不建议使用interrupt和stop
  }
}

class MyThread extends Thread {
	boolean flag = true;
	public void run(){
		while(flag){
			//若调用该线程的主线程还“活着”
			if(Thread.currentThread().isAlive()) {
				System.out.println("==="+new Date()+"===");
			}

			try {
	                //public static sleep（long millis）throw InterruptedException
			//使得当前线程休眠，暂停执行millis毫秒
				sleep(1000); //1000毫秒，即1s
			} catch (InterruptedException e) {
				//重写的方法不能抛出比被重写的方法不同的异常
				//此处只能写try catch，不能写throws
				return;
			}
		}
	}
}

（3）线程合并

public class Main {
  public static void main(String[] args) {
    MyThread2 t1 = new MyThread2("myThread");
    t1.start();
    try {
    	t1.join();
    } catch (InterruptedException e) {}

    for(int i=1;i<=3;i++){
      System.out.println("i am main thread");
    }
  }
}
class MyThread2 extends Thread {
  MyThread2(String s){
  	super(s);//设置当前线程名为 s
  }

  public void run(){
    for(int i =1;i<=3;i++){
      System.out.println("i am "+getName());//输出线程名
    }
  }
}//线程合并结果，相当于方法调用

三、线程同步与死锁

1、线程同步

      Java引入了对象互斥锁的概念，使用synchronized修饰符修饰方法和代码块，表明在某一时间段内，只能有一个线程访问被锁住的同步对象或同步方法，以保证共享数据的完整性；但其他线程仍可以访问没有锁定的方法，所以，要想保证数据同步，需将所有改变该属性值的方法都加锁，但锁加的越多，执行效率会被降低。建议对于读属性的方法无需加锁  。

public class Main implements Runnable {

	private static int num = 100;

	public static void main(String[] args) throws Exception {
		Main test = new Main();
	    Thread t1 = new Thread(test);
	    Thread t2 = new Thread(test);
	    //设置线程名字
	    t1.setName("t1");
	    t2.setName("t2");
	    //启动线程
	    t1.start();
	    t2.start();

	   // test.m2();//使t1和t2同步
	   // test.m3();//使t1、t2和主线程 同步	   
	   // System.out.println("Main"+" : "+(num));
	}
	 //在某一时间段，保证只有一个线程访问被锁住的方法
	public synchronized void m1(){
		//若不使用死锁，num++和num输出 的原子性过程可能会打断,结果是都是102或101
		num++;
		System.out.println(Thread.currentThread().getName() +": "+ num);
	}

	//其他线程仍可以访问没有锁定的方法,导致数据有可能不同步
	public  void m2() {
		num++;
	}

	//要想保证数据同步，需将所有改变该属性值的方法都加锁
	public  void m3() {
		synchronized (this) {//互斥锁
			num++;
		}
	  }

	public void run() {
		try {
			m1();
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}

2、线程死锁

（1）死锁实例

public class Main  implements Runnable {
	public int flag = 1;
	static Object o1 = new Object(), o2 = new Object();

	public static void main(String[] args) {
		Main td1 = new Main();
		Main td2 = new Main();
		td1.flag = 1;
		td2.flag = 0;
		Thread t1 = new Thread(td1);
		Thread t2 = new Thread(td2);
		t1.start();
		t2.start();
	}

	public void run() {
		System.out.println("flag=" + flag);
		if(flag == 1) {
			synchronized(o1) {
				try {
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				synchronized(o2) {
					System.out.println("1");
				}
			}
		}
		if(flag == 0) {
			synchronized(o2) {
				try {
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				synchronized(o1) {
					System.out.println("0");
				}
			}
		}
	}
}

四、经典同步问题

1、生产者消费者

public class Main {
	public static void main(String[] args) {
		SyncStack ss = new SyncStack();

		//生成者
		Producer p = new Producer(ss);
		new Thread(p).start();

		//消费者
		Consumer c = new Consumer(ss);
		new Thread(c).start();
	}
}

class WoTou {
	int id;
	WoTou(int id) {
		this.id = id;
	}
	public String toString() {
		return "WoTou : " + id;
	}
}

//支持多线程同步操作的堆栈的实现
class SyncStack {
	private int index = 0;
	private WoTou[] arrWT = new WoTou[6];

	public synchronized void push(WoTou wt) {
		while(index == arrWT.length) {
			try {
				//Object的wait只能在synchronized修饰的方法中使用
				//让当前正在访问的线程wait
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();//唤醒所有线程，此处也可使用notify()唤醒一个线程;

		arrWT[index] = wt;
		index ++;
	}

	public synchronized WoTou pop() {
		//不能写if,在发生异常后还需在判断index值
		while(index == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();//	notify();
		index--;
		return arrWT[index];
	}
}

class Producer implements Runnable {
	SyncStack ss = null;
	Producer(SyncStack ss) {
		this.ss = ss;
	}

	public void run() {
		for(int i=0; i<20; i++) {
			WoTou wt = new WoTou(i);
			ss.push(wt);
			System.out.println("生产了：" + wt);

			try {
				Thread.sleep((int)(Math.random() * 200));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class Consumer implements Runnable {
	SyncStack ss = null;
	Consumer(SyncStack ss) {
		this.ss = ss;
	}

	public void run() {
		for(int i=0; i<20; i++) {
			WoTou wt = ss.pop();
			System.out.println("消费了: " + wt);
			try {
				Thread.sleep((int)(Math.random() * 1000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

2、银行家算法