Java中多线程的创建和使用

一、基本概念：程序-进程-线程

程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程（process）：是程序的一次执行过程， 或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。

    >如：运行中的QQ,运行中的MP3播放器

    >程序是静态的，进程是动态的

线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。

    >若一个程序可同一时间执行多个线程，就是支持多线程的

何时需要多线程

    ①程序需要同时执行两个或多个任务。

    ②程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

    ③需要一些后台的运行程序时。

二、如何实现多线程的创建（两种方式）和启动

1.继承Thread类

    1）子类继承Thread类

    2）重写Thread类的run()方法？            run()中是创建的多线程主要的实现的功能。

    3）创建子类的对象（创建了几个，就有几个线程）

    4）启动： 对象.start();

package com.atguigu.thread;

/*
 * 创建一个子线程，完成1~100之间自然数的输出。同样地，主线程执行同样的操作
 * 创建多线程的第一种方式：继承java.lang.Thread类
 */
//1.创建一个继承于Thread的子类
class SubThread extends Thread {
	// 2.重写Thread类的run方法，方法内 实现此子线程要完成的功能
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+"："+i);
		}
	}
}

public class TestThread {
	public static void main(String[] args) {
		//3.创建一个子类的对象
		SubThread st = new SubThread();
		//4.调用线程的start()：启动此线程：调用相应的run()方法
		st.start();
		
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+"："+i);
		}
	}
}

注意：一个线程只能执行一次start(），否则会报java.lang.IllegalThreadStateException异常

底层源码剖析

Thread的常用方法

package com.atguigu.thread;

/*
 * Thread的常用方法：
 * 1.start():启动线程并执行相应的run()方法
 * 2.run()：子线程要执行的代码放入run()方法中
 * 3.currewntThread():静态的，调取当前的线程
 * 4.getName():获取此线程的名字
 * 5.setName():设置此线程的名字
 * 6.yield():调用此方法的线程释放当前CPU的执行权
 * 7.join():在A线程中调用B线程的join()方法，表示当执行到此方法，A线程停止执行，直至B线程执行完毕，A线程再接着join()之后的代码执行
 */
class SubThread1 extends Thread {
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+"："+i);
		}
	}
}

public class TestThread1 {
	public static void main(String[] args) {
		
		SubThread1 st1 = new SubThread1();
		st1.setName("子线程");
		st1.start();
		Thread.currentThread().setName("===========主线程");
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+"："+i);
//			if (i% 10 == 0) {
//				Thread.currentThread().yield();
//			}
			if (i == 20) {
				try {
					st1.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

2.实现Runnable接口

    1）子类实现Runnable接口

    2）重写Runnable接口的run()方法

    3）创建一个子类的实例

    4）将子类的实例作为实参传递给Thread的构造器中

    5）启动： 对象.start();

//1.创建一个实现了Runnable接口的实现类
class PrintNum1 implements Runnable{
	//2.实现接口的抽象方法
	@Override
	public void run() {
		//子线程执行的代码
		for (int i = 1; i <= 100; i++) {
			if (i%2==0) {
				System.out.println(Thread.currentThread().getName()+"："+i);
			}
		}
	}
	
}
public class TestThread2 {
	public static void main(String[] args) {
		//3.创建一个Runnable接口实现类的对象
		PrintNum1 p = new PrintNum1();
		//要想启动一个多线程，必须调用start()
		//4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
		Thread t1 = new Thread(p);
		//5.调用start()方法：启动线程并执行Run
		t1.start(); //启动线程；执行Thread对象生成时构造器形参的对象的run()方法。
		
		//再创建一个线程
		Thread t2 = new Thread(p);
		t2.start();
	}
}

对比一下继承的方式 vs 实现的方式
1).联系：public class Thread implements Runnable
2).哪个方式好？实现的方式优于继承的方式
why? ①避免了java单继承的局限性

②如果多个线程要操作同一份资源（或数据），更适合使用实现的方式