多线程（一） —— 认识多线程

目录

了解进程与线程的区别

掌握Java线程的两种实现方式及其区别

了解线程的操作状态

---

了解进程与线程的区别

• 进程是程序的一次动态执行过程，它经历了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。
• 多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。

掌握Java线程的两种实现方式及其区别

在Java中要想实现多线程代码有两种手段：

• 一种是继承Thread类

          Thread类是在java.lang包中定义的，一个类只要继承了Thread类，此类就称为多线程操作类。在Thread子类之中，必须明确的覆写Thread类中的run()方法，此方法为线程的主体。

class 类名称 extends Thread{		// 继承Thread类	
		属性… ; 			// 类中定义属性	
		方法… ; 			// 类中定义方法	
		 // 覆写Thread类中的run()方法，此方法是线程的主体
		public void run(){			
			线程主体;
		}
	}

继承Thread类实现多线程 

package com.dong1990;

public class fifth {
	
	public static void main(String args[]) {
		MyThread mt1 = new MyThread("线程A ");	// 实例化对象
		MyThread mt2 = new MyThread("线程B ");	// 实例化对象
		mt1.run();				// 调用线程主体
		mt2.run();				// 调用线程主体
	}

}
class MyThread extends Thread {			// 继承Thread类
	private String name;				// 在类中定义一个属性
	public MyThread(String name) {			// 通过构造方法设置属性内容
		this.name = name;				// 为name属性赋值
	}
	public void run() {				// 覆写Thread类中的run()方法
		for (int i = 0; i < 10; i++) {		// 循环10次输出
			System.out.println(name + "运行，i = " + i);
		}
	}
}

如果要想正确的启动线程，是不能直接调用run()方法的，应该调用从Thread类中继承而来的start()方法，才可以启动线程。
mt1.start();            // 启动多线程
mt2.start();            // 启动多线程

• 一种就是实现Runnable接口

           在Java中也可以通过实现Runnable接口的方式实现多线程，Runnable接口中只定义了一个抽象方法：

public void run() ;

         通过Runnable接口实现多线程

class 类名称 implements Runnable{	// 实现Runnable接口
		属性… ; 			// 类中定义属性	
		方法… ; 			// 类中定义方法	
		public void run(){            	// 覆写Runnable接口里的run()方法		线程主体 ; 
		}
	}

package com.dong1990;

public class fifth {
	
	public static void main(String args[]) {
		MyThread mt1 = new MyThread("线程A ");	// 实例化对象
		MyThread mt2 = new MyThread("线程B ");	// 实例化对象
		mt1.run();				// 调用线程主体
		mt2.run();				// 调用线程主体
	}

}
class MyThread implements Runnable {			// 继承Thread类
	private String name;				// 在类中定义一个属性
	public MyThread(String name) {			// 通过构造方法设置属性内容
		this.name = name;				// 为name属性赋值
	}
	public void run() {				// 覆写Thread类中的run()方法
		for (int i = 0; i < 10; i++) {		// 循环10次输出
			System.out.println(name + "运行，i = " + i);
		}
	}
}

 以上的代码是通过实现Runnable接口实现的多线程，但是这样一来就会有新的问题产生了，从之前的代码中可以清楚的知道，要想启动一个多线程必须要使用start()方法完成，如果继承了Thread类，则可以直接从Thread类中使用start()方法，但是现在实现的是Runnable接口，那么该如何启动多线程呢？实际上此时，还是要依靠Thread类完成启动，在Thread类中提供了以下的两个构造方法：

1. public Thread(Runnable target)
2. public Thread(Runnable target,String name)

这两个构造方法都可以接收Runnable的子类实例对象。所以就可以依靠此点启动多线程。

package com.dong1990;

public class fifth {
	
	public static void main(String args[]) {
		
		MyThread my1 = new MyThread("线程A ");	// 实例化Runnable子类对象
		MyThread my2 = new MyThread("线程B ");	// 实例化Runnable子类对象
		Thread t1 = new Thread(my1) ;		// 实例化Thread类对象
		Thread t2 = new Thread(my2) ;		// 实例化Thread类对象
		t1.start() ;				// 启动线程
		t2.start() ;				// 启动线程
		
	}

}
class MyThread implements Runnable {			// 继承Thread类
	private String name;				// 在类中定义一个属性
	public MyThread(String name) {			// 通过构造方法设置属性内容
		this.name = name;				// 为name属性赋值
	}
	public void run() {				// 覆写Thread类中的run()方法
		for (int i = 0; i < 10; i++) {		// 循环10次输出
			System.out.println(name + "运行，i = " + i);
		}
	}
}

Thread类和Runnable接口的区别

           实际上Thread类和Runnable接口之间在使用上也是有所区别的，如果一个类继承Thread类，则不适合于多个线程共享资源。

            而实现了Runnable接口，则可以方便的实现资源的共享。

继承Thread类不能资源共享

package com.dong1990;

public class fifth {
	
	public static void main(String args[]) {
		
		MyThread mt1 = new MyThread("线程A") ;		// 定义线程对象
		MyThread mt2 = new MyThread("线程B") ;		// 定义线程对象
		MyThread mt3 = new MyThread("线程C") ;		// 定义线程对象
		mt1.start() ;				// 启动第一个线程
		mt2.start() ;				// 启动第二个线程
		mt3.start() ;				// 启动第三个线程
		
	}

}
class MyThread extends Thread {			// 继承Thread类
	private int ticket = 5 ;			// 一共5张票
	private String name;			// 在类中定义一个属性
	public MyThread(String name) {		// 通过构造方法设置属性内容
		this.name = name;			// 为name属性赋值
	}
	public void run(){				// 覆写run()方法
		for(int i=0;i<100;i++){			// 超出票数的循环
			if(ticket>0){			// 判断是否有剩余票
				System.out.println(name+" 卖票：ticket = " + ticket--) ;
			}
		}
	}

}

实现Runnable接口可以资源共享

package com.dong1990;

public class fifth {
	
	public static void main(String args[]) {
		
		MyThread my = new MyThread("线程A") ;
		new Thread(my).start() ;			// 启动三个线程
		new Thread(my).start() ;			// 启动三个线程
		new Thread(my).start() ;			// 启动三个线程
		
	}

}
class MyThread implements Runnable {			// 继承Thread类
	private int ticket = 5 ;			// 一共5张票
	private String name;			// 在类中定义一个属性
	public MyThread(String name) {		// 通过构造方法设置属性内容
		this.name = name;			// 为name属性赋值
	}
	public void run(){				// 覆写run()方法
		for(int i=0;i<100;i++){			// 超出票数的循环
			if(ticket>0){			// 判断是否有剩余票
				System.out.println(name+" 卖票：ticket = " + ticket--) ;
			}
		}
	}

}

总结：

实现Runnable接口相对于继承Thread类来说，有如下显著的优势：
（1）、适合多个相同程序代码的线程去处理同一资源的情况。
（2）、可以避免由于Java的单继承特性带来的局限。
（3）、增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。

了解线程的操作状态

要想实现多线程，必须在主线程中创建新的线程对象。任何线程一般具有五种状态，即创建、就绪、运行、阻塞、终止。