java多线程

      java多线程是java基础中的重点，下面就java的多线程进行详细讲解。

1、进程和线程概念

      进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。
      线程是指进程中的一个执行流程，一个进程中可以运行多个线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。
2、线程实现的两种方式

      在java中，实现多线程的方式有两种，一个是继承Thread类，另一个是实现Runnable接口。

      （1）继承Thread类方法

      在java中，一个类如果继承Thread类，同时覆写本类的run()方法，则该类就实现了多线程的操作。在操作多线程时，我们需要通过该类的实例去调用多线程的start()方法，该方法一旦被调用，JVM会自动调用run()方法。当有多个类的实例启动start()方法。则程序会进行交互式的运行run()方法体的内容，如下程序就证明了这点。该方法一个类只能继承一个父类，所以比较有限，start方法中通过JNI技术调用操作系统的底层函数实现的。

 代码如下：

public class MyThread extends Thread {
	private String name; // 定义name属性
	public MyThread(String name) {
		this.name = name;
	}
	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			System.out.println("Thread运行：" + name + "，i = " + i);
		}
	}
}

public class ThreadDemo{
	public static void main(String[] args) {
		MyThread mt1 = new MyThread("线程A");
		MyThread mt2 = new MyThread("线程B");
		mt1.start(); // 调用线程体
		mt2.start(); // 调用线程体

	}
}

 运行结果：

Thread运行：线程A，i = 0
Thread运行：线程A，i = 1
Thread运行：线程A，i = 2
Thread运行：线程A，i = 3
Thread运行：线程A，i = 4
Thread运行：线程A，i = 5
Thread运行：线程A，i = 6
Thread运行：线程A，i = 7
Thread运行：线程A，i = 8
Thread运行：线程A，i = 9
Thread运行：线程A，i = 10
Thread运行：线程A，i = 11
Thread运行：线程A，i = 12
Thread运行：线程A，i = 13
Thread运行：线程A，i = 14
Thread运行：线程A，i = 15
Thread运行：线程A，i = 16
Thread运行：线程A，i = 17
Thread运行：线程A，i = 18
Thread运行：线程A，i = 19
Thread运行：线程B，i = 0
Thread运行：线程A，i = 20
Thread运行：线程B，i = 1
Thread运行：线程A，i = 21
Thread运行：线程B，i = 2
Thread运行：线程A，i = 22
Thread运行：线程B，i = 3
Thread运行：线程A，i = 23
Thread运行：线程B，i = 4
Thread运行：线程A，i = 24

 （2）实现Runable接口方法

         该方式是一个类implements Runable接口中的run方法，Runnable接口中只有一个run方法。要启动该类实现多线程方法，还要借助Thread类，因为Thread类的构造方法的参数是一个Runable接口，通过将该类传入到Thread类中的构造函数中实现了线程的启动，从而实现程序的多线程交互操作。

public class MyThread implements Runnable { // 实现Runnable接口
	private String name; // 定义name属性

	public MyThread(String name) {
		this.name = name;
	}

	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			System.out.println("Thread运行：" + name + "，i = " + i);
		}
	}
}

 

public class RunnableDemo01 {
	public static void main(String[] args) {
		MyThread mt1 = new MyThread("线程A");
		MyThread mt2 = new MyThread("线程B");
		new Thread(mt1).start(); // 调用线程体
		new Thread(mt2).start(); // 调用线程体
	}
}

（3）两种实现方式的区别和联系

        在软件的开发过程中，实现Runable接口的方法是正统操作，因为实现Runnable接口比继承Thread类具有如下的优点：

（I） 避免了单一继承的局限，一个类可以实现多个接口。

（II）适合于资源共享。

       下面以买票的例子来说明资源的共享，已知一共有五张票，同时启动3个线程进行买票，继承Thread接口的不能实现资源共享，而实现Runnable接口的可以实现资源共享。

public class MyThread extends Thread {// 继承Thread类
	private int ticket = 5; // 一共才5张票
	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			if (this.ticket > 0) {
				System.out.println("卖票：ticket = " + this.ticket--);
			}
		}
	}
}
public class ThreadTicket {
	public static void main(String[] args) {
		MyThread mt1 = new MyThread(); // 一个线程
		MyThread mt2 = new MyThread(); // 一个线程
		MyThread mt3 = new MyThread(); // 一个线程
		mt1.start() ;	// 开始卖票
		mt2.start() ;	// 开始卖票
		mt3.start() ;	// 开始卖票
	}
}

 测试结果：每个线程各自卖各自的票，并未实现资源共享。

卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1
卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1
卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1

 而Runnable接口却实现了资源的共享

public class MyThread implements Runnable {// 实现Runnable接口
	private int ticket = 5; // 一共才5张票
	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			if (this.ticket > 0) {
				System.out.println("卖票：ticket = " + this.ticket--);
			}
		}
	}
}
public class RunnableTicket {
	public static void main(String[] args) {
		MyThread mt = new MyThread(); // 一个线程
		new Thread(mt).start() ;	// 开始卖票
		new Thread(mt).start() ;	// 开始卖票
		new Thread(mt).start() ;	// 开始卖票
	}
}

 测试结果：

卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1

      由于Thread类本身继承object类，同时实现了Runnable接口，而我们实现的Runnable接口，在启动线程过程中通过Thread类的构造函数传出我们实现的类，其实里面存在代理模式的设计。

 

 

 3、线程的状态

 

 线程基本的五个状态：创建（start），可执行（Runnable），被阻塞（blocked），运行（running）和结束 （death）状态。

4、线程的操作

（1）基本操作

 java在运行的时候，至少要启动2个线程，一个是主线程，一个是gc线程。

（2）状态操作

 判断线程状态的方法：public final boolean isAlive();注意线程的每次运行状态是不一致的。

（3）强制线程的执行

 在一个线程A执行过程中，可以强行让B线程加入执行，等待B线程按规定执行完毕后再继续执行A线程，则可以用join（）方法完成该需求。

（4）线程的睡眠

 thread.sleep()可以让线程进入阻塞状态。

（5）线程的中断

（6）线程的优先级

 注意：主线程的优先级默认为普通优先级。

（7）等待与通知

wait（），notify（）与notifyall（）是Object定义的方法，可以通过这三个方法控制线程释放对象的锁定。或者通知线程参与锁定竞争。

wait（）可以指定等待时间，时间到后线程加入排班，如果指定时间0或不指定，则线程会持续等待，直到被中断（调用interrupt（））或是告知（notify（））可以参与排班。

下面就wait（）notify（）的应用，生产者和消费者问题

package com.jason.util;

public class Clerk {
	
	private int product = -1;//只有一个产品存储空间，-1表示没有产品
	
	/**
	 * @param product
	 */
	public synchronized void setProduct(int product){
		while(this.product != -1){
			try {
				wait();		//目前没有空间放产品处于等待状态
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
		}
		this.product = product;
		System.out.println("生产者设定"+this.product);
		notify();			//通知等待中的线程如消费者
	}
	
	/**
	 * @return
	 */
	public synchronized int getProduct(){
		
		while(this.product == -1){
			try {
				wait();		//目前没有产品，处于等待状态
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
		}
		
		int p = this.product;
		System.out.println("消费者取走"+this.product);
		this.product = -1;	//表示货品被取走
		notify();			//通知等待中的线程如生产者
		return p;
	}
}

 

package com.jason.util;

public class Producer implements Runnable {
	
    private Clerk clerk; 
    
    public Producer(Clerk clerk) { 
        this.clerk = clerk; 
    } 
    
    public void run() { 
        System.out.println("生产者开始生产整数......"); 
        for(int product = 1; product <= 10; product++) { 
            try { 
                Thread.sleep((int) (Math.random() * 3000)); 
            } 
            catch(InterruptedException ex) { 
                throw new RuntimeException(ex);
            } 
            clerk.setProduct(product); 
        }       
    } 
}

 

package com.jason.util;

public class Consumer implements Runnable {

	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		
		System.out.println("消费者开始消费整数。。。。。");
		
		for(int i = 1; i <=10;i++){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
			int product = clerk.getProduct();
		}
	}
}

 

package com.jason.util;

public class ProductConsumerDemo {

	 public static void main(String[] args) {
        Clerk clerk = new Clerk(); 
        new Thread(new Producer(clerk)).start(); 
        new Thread(new Consumer(clerk)).start(); 
	 }    
}

 运行结果：

生产者开始生产整数......
消费者开始消费整数。。。。。
生产者设定1
消费者取走1
生产者设定2
消费者取走2
生产者设定3
消费者取走3
生产者设定4
消费者取走4
生产者设定5
消费者取走5
生产者设定6
消费者取走6
生产者设定7
消费者取走7
生产者设定8
消费者取走8
生产者设定9
消费者取走9
生产者设定10
消费者取走10