Java线程简单案列

这里主要介绍了线程的创建的常用两种方式：

(1)通过继承Thread类直接创建线程对象；

(2)通过继承Runnable借口间接创建线程对象；

第一种：通过继承Thread类直接创建线程对象；

第一步：定义一个类继承Thread类；

第二步：重新定义run（）方法；

第三步：实例化线程对象；

第四步：结束线程；

public class ThreadDemo {
	
	//线程A
	static class ThreadA extends Thread{
		public int distance;
		
		public void run() {
			distance = 0;
			
			for(int i = 0;i<10;i++){
				distance += 1;
				System.out.println("线程A" +"  "+distance);
				
				try {
					sleep((long) (Math.random() * 1000));//当前线程睡眠随机数产生
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("线程A运行完毕");
			
		}
	}
	
	//线程B
	static class ThreadB extends Thread{
		public int distance;
		
		public void run() {
			distance = 0;
			
			for(int i = 0;i<10;i++){
				distance += 1;
				System.out.println("线程B" +"  "+distance);
				
				try {
					sleep((long) (Math.random() * 1000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("线程B运行完毕");
			
		}
	}
	
	public static void main(String[] args) {
		ThreadA threadA = new ThreadA();
		threadA.start();
		ThreadB threadB = new ThreadB();
		threadB.start();
	}
}

第二种：通过继承Runnable借口间接创建线程对象；

第一步：定义一个类，实现Runnable接口

如下面 static class ThreadA implements Runnable{......}（动态类在静态方法不能实例化，所以加上static）

第二步：重新定义run（）方法；（相当于主程序main方法）

第三步：实例化线程对象

第四步：启动线程

public class RunnableDemo {
	
	//线程A
	static class ThreadA implements Runnable{
		public int distance;

		@Override
		public void run() {
			distance = 0;
			for(int i = 0;i < 10;i++){
				distance += 1;
				System.out.println("线程A" + "  " + distance);
				
				try {
					Thread.sleep((long) (Math.random()*1000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.print("线程A运行完毕");
		}
	}
	
	
	//线程B
	static class ThreadB implements Runnable{
		public int distance;
		
		@Override
		public void run() {
			distance =0;
			for(int i = 0;i<10;i++){
				distance += 1;
				System.out.println("线程B" + "  " +distance);
			}
			try {
				Thread.sleep((long) (Math.random()*1000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("线程B运行完毕");
		}
	}

	public static void main(String[] args) {
		ThreadA threadA = new ThreadA();
		Thread A = new Thread(threadA);
		A.start();
		
		ThreadB threadB = new ThreadB();
		Thread B = new Thread(threadB);
		B.start();

 }
}

对比创建两种线程的方法

（1）直接继承Thread类的线程，在实例化线程中已存在包含线程体run()方法；

ThreadA threadA = new ThreadA();
		threadA.start();
		ThreadB threadB = new ThreadB();
		threadB.start();

（2）实现Runnable接口的线程创建方法，在一个非线程对象定义一个run（）方法，实例化线程对象要调用这个线程体就要与非线程体建立连接。

ThreadA threadA = new ThreadA();
		Thread A = new Thread(threadA);
		A.start();
		
		ThreadB threadB = new ThreadB();
		Thread B = new Thread(threadB);
		B.start();

（3）直接继承Thread类，适用于单重继承，不能再继承其他类；

（4）实现Runnable类，当一个线程继承另一个类时，就只能实现Runnable接口的方法来创建线程。