Java多线程--认识多线程（Thread、Runnable）

1、进程与线程

dos系统：单进程。只能有一个程序独自运行，其他程序无法运行。

windows系统：多进程。同一时间段上有多个程序同时运行。

2、java的多线程实现

在java中实现多线程可以采用两种方式：

继承Thread类。

实现Runnable接口。

3、Thread类

java.lang包会在程序运行时自动导入，所以不用编写import语句。

class MyThread extends Thread{	// 继承Thread类，作为线程的实现类
	private String name ;		// 表示线程的名称
	public MyThread(String name){
		this.name = name ;		// 通过构造方法配置name属性
	}
	public void run(){	// 覆写run()方法，作为线程 的操作主体
		for(int i=0;i<10;i++){
			System.out.println(name + "运行，i = " + i) ;
		}
	}
};

以上完成了一个线程的操作类，然后直接使用此类就可以完成功能。

class MyThread extends Thread{	// 继承Thread类，作为线程的实现类
	private String name ;		// 表示线程的名称
	public MyThread(String name){
		this.name = name ;		// 通过构造方法配置name属性
	}
	public void run(){	// 覆写run()方法，作为线程 的操作主体
		for(int i=0;i<10;i++){
			System.out.println(name + "运行，i = " + i) ;
		}
	}
};
public class ThreadDemo01{
	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(){	// 覆写run()方法，作为线程 的操作主体
		for(int i=0;i<10;i++){
			System.out.println(name + "运行，i = " + i) ;
		}
	}
};
public class ThreadDemo02{
	public static void main(String args[]){
		MyThread mt1 = new MyThread("线程A ") ;	 // 实例化对象
		MyThread mt2 = new MyThread("线程B ") ;	 // 实例化对象
		mt1.start() ;	// 调用线程主体
		mt2.start() ;	// 调用线程主体
	}
};

class MyThread extends Thread{	// 继承Thread类，作为线程的实现类
	private String name ;		// 表示线程的名称
	public MyThread(String name){
		this.name = name ;		// 通过构造方法配置name属性
	}
	public void run(){	// 覆写run()方法，作为线程 的操作主体
		for(int i=0;i<10;i++){
			System.out.println(name + "运行，i = " + i) ;
		}
	}
};
public class ThreadDemo03{
	public static void main(String args[]){
		MyThread mt1 = new MyThread("线程A ") ;	 // 实例化对象
		mt1.start() ;	// 调用线程主体
		mt1.start() ;	// 错误
	}
};

4、实现Runnable接口

class MyThread implements Runnable{	// 实现Runnable接口，作为线程的实现类
	private String name ;		// 表示线程的名称
	public MyThread(String name){
		this.name = name ;		// 通过构造方法配置name属性
	}
	public void run(){	// 覆写run()方法，作为线程 的操作主体
		for(int i=0;i<10;i++){
			System.out.println(name + "运行，i = " + i) ;
		}
	}
};

class MyThread implements Runnable{	// 实现Runnable接口，作为线程的实现类
	private String name ;		// 表示线程的名称
	public MyThread(String name){
		this.name = name ;		// 通过构造方法配置name属性
	}
	public void run(){	// 覆写run()方法，作为线程 的操作主体
		for(int i=0;i<10;i++){
			System.out.println(name + "运行，i = " + i) ;
		}
	}
};
public class RunnableDemo01{
	public static void main(String args[]){
		MyThread mt1 = new MyThread("线程A ") ;	 // 实例化对象
		MyThread mt2 = new MyThread("线程B ") ;	 // 实例化对象
		
		Thread t1 = new Thread(mt1) ;		// 实例化Thread类对象
		Thread t2 = new Thread(mt2) ;		// 实例化Thread类对象
		t1.start() ;	// 启动多线程
		t2.start() ;	// 启动多线程
	}
};

运行效果：

5、Thread类与Runnable接口的联系

从定义格式上可以发现：Thread类也是Runnable接口的子类。

从类的关系上看，之前的做法非常类似于代理设计模式，Thread类完成比线程主体更多的操作。例如：分配cpu、判断是否已经启动等等。

6、Thread类与Runnable接口的区别

使用Thread类在操作多线程的时候，无法达到资源共享的母的。而使用Runnable接口实现的多线程可以实现资源共享。

class MyThread extends Thread{	// 继承Thread类，作为线程的实现类
	private int ticket = 5 ;		// 表示一共有5张票
	public void run(){	// 覆写run()方法，作为线程 的操作主体
		for(int i=0;i<100;i++){
			if(this.ticket>0){
				System.out.println("卖票：ticket = " + ticket--) ;
			}
		}
	}
};
public class ThreadDemo04{
	public static void main(String args[]){
		MyThread mt1 = new MyThread() ;	 // 实例化对象
		MyThread mt2 = new MyThread() ;	 // 实例化对象
		MyThread mt3 = new MyThread() ;	 // 实例化对象
		mt1.run() ;	// 调用线程主体
		mt2.run() ;	// 调用线程主体
		mt3.run() ;	// 调用线程主体
	}
};

三个线程各自卖各自的5张票，没有达到资源共享。

class MyThread implements Runnable{	// 继承Thread类，作为线程的实现类
	private int ticket = 5 ;		// 表示一共有5张票
	public void run(){	// 覆写run()方法，作为线程 的操作主体
		for(int i=0;i<100;i++){
			if(this.ticket>0){
				System.out.println("卖票：ticket = " + ticket--) ;
			}
		}
	}
};
public class RunnableDemo02{
	public static void main(String args[]){
		MyThread mt = new MyThread() ;	 // 实例化对象
		new Thread(mt).run() ;	// 调用线程主体
		new Thread(mt).run() ;	// 调用线程主体
		new Thread(mt).run() ;	// 调用线程主体
	}
};

虽然启动了三个线程，三个线程总共卖出了5张票。达到资源共享。

7、Thread类与Runnable接口使用结论

8、线程的状态

实际上，线程调用start()方法的时候不是立刻启动的，而是等待cpu进行调度的。

9、总结