Java多线程学习(线程的两种实现方式)

基础知识

并发：在同一时间段中交替执行
并行：同一时刻同时执行

进入到内存中的程序叫做进程。线程是进程的执行单元，一个进程可以包含多个线程。
线程调度：
分时调度；轮流使用cpu资源。
抢占式：优先级高的线程抢占CPU，java使用的是抢占式。

主线程：执行主方法的线程。

创建多线程第一种方式

创建Thread类的子类。java.lang.Thread类：描述线程的类，我们想实现线程，必须继承这个类。
实现步骤：
1：创就一个Thread子类
2：在Thread子类中重写Thread的run方法，设置线程任务。
3：创建Thread子类的对象。
4：调用Thread类中的start方法。开启新的线程调用run方法。

代码示例：

public class MyThread extends Thread{
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i = 0;i<=20;i++) {
			System.out.println("main"+i);
		}
	}
}
public class TestMyThread {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyThread mt = new MyThread();
		mt.start();//调用线程的方法，启动run方法。
		for(int i = 0; i<=20;i++) {
			System.out.println("run"+i);
		}//又开启一个线程任务。
	}
}
run0
main0
run1
main1
...

JVM执行main方法，开辟了一条main方法通向CPU的路径，这个路径叫主线程。CPU通过主线程执行main方法，这个时候CPU根据优先级（优先级相同的话随机执行线程）。

获取线程的名称： getName()方法。

public class MyThread extends Thread{
	@Override
	public void run() {
		String ThreadName = getName();
		System.out.println(ThreadName);
		//System.out.println(Thread.currentThread().getName());获取当前执行的线程名称。
	}
}
public class TestMyThread {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyThread mt = new MyThread();
		mt.start();//调用线程的方法
		
		new MyThread().start();//又开启一个线程
	}
}
Thread-0
Thread-1

设置线程名称：
1：使用Thread类中的setName()方法。
2：创建一个带参数的构造方法，参数传递线程名称，调用父类带参构造方法，把线程名称传递给父类，让父类（Thread）给子线程起一个名字

public class ThreadSetName extends Thread{
	//无参构造方法
	public ThreadSetName() {
	}
	public ThreadSetName(String name) {//创建一个父类构造方法
		super(name);//把线程名称传递给父类
	}
	@Override
	public void run() {
		//获取当前线程的名称
		System.out.println(Thread.currentThread().getName());
	}
}
public class TestSetName {

	public static void main(String[] args) {
		ThreadSetName ts = new ThreadSetName();
		ts.setName("海绵宝宝线程");
		ts.start();
		
		new ThreadSetName("派大星线程").start();//让父类给子线程起一个名字。
	}
}
//海绵宝宝线程
//派大星线程

sleep()方法。

public class SleepDe {

	public static void main(String[] args) {
		for(int i = 1; i<10;i++) {
			System.out.println(i);
			try {
				Thread.sleep(1000);//每打印一次就睡眠1000
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

创建多线程的第二种方法

实现Runable接口。
实现步骤：
1：创建一个Runable实现类
2：在实现类中重写Runable接口的run方法。设置线程任务
3：创建一个Runable实现类对象。
4：创建Thread类对象，构造方法传递Runable接口的实现类对象。
5：调用Thread类中的start方法，开启新的线程执行run方法。

public class RunableImp implements Runnable{
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i = 0;i<=3;i++) {
			System.out.println(Thread.currentThread().getName()+"->"+i);
		}
	}
}
public class RunableTest {

	public static void main(String[] args) {
		RunableImp rimp = new RunableImp();
		Thread th = new Thread(rimp);
		th.start();
		//主线程
		for(int i = 0;i<=3;i++) {
			System.out.println(Thread.currentThread().getName()+"->"+i);
		}
	}
}
main->0
main->1
Thread-0->0
main->2
main->3
Thread-0->1
Thread-0->2
Thread-0->3//cpu随机执行线程

总结：使用Runable的优点：使用多线程以后尽量使用接口。
1：避免了单继承的局限性，可以有多个实现类实现Runable接口。而继承了Thread就不能继承其他类。
2：增强了程序的扩展性，降低了耦合性。实现Runable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）。
实现类中，重新run方法，用来设置线程任务。
创建Thread类对象，调用start用来开启新线程。

匿名内部类实现线程的创建。
作用：简化代码。创建Thread类，Runable接口，重写接口中的方法，创建实现类对象和成一步完成。
格式：

new 父类/接口(){
	//重写父类/接口中的方法。
}

public class NimingThread {

	public static void main(String[] args) {
		new Thread() {//实现类接口
			@Override
			public void run() {//重写接口中的方法
				// TODO Auto-generated method stub
				for(int i = 0;i<=3;i++) {
					System.out.println(Thread.currentThread().getName()+"->"+i);
				}
			}
		}.start();//调用start方法
		
		Runnable ra = new Runnable() {
			@Override
			public void run() {
				for(int i = 0;i<=3;i++) {
					System.out.println("海绵宝宝线程"+"->"+i);
				}
			}
		};
		new Thread(ra).start();
		
		//或者
		new Thread(
			new Runnable() {
				@Override
				public void run() {
					for(int i = 0;i<=3;i++) {
						System.out.println("派大星线程"+"->"+i);
					}
				}
			}
		).start();
	}
}
Thread-0->0
Thread-0->1
Thread-0->2
Thread-0->3
海绵宝宝线程->0
海绵宝宝线程->1
海绵宝宝线程->2
海绵宝宝线程->3
派大星线程->0
派大星线程->1
派大星线程->2
派大星线程->3