多线程

进程

每一个应用程序在运行时，都会产生至少一个进程（process）。

进程是操作系统进行“资源分配和调度”的独立单位。

Windows系统的“任务管理器”可以查看系统的进程，通过Ctrl+Shift+Esc组合键可以调出“任务管理器”。

进程具有三个特征：

独立性：进程拥有自己独立的资源，有私有的地址空间。
动态性：程序是静态的指令集合，而进程是活动的指令集合，进程有其生命周期。
并发性：多个进程可以在同一个处理器上并发执行，互不影响。虽然同一时刻只能有一个进程执行，但是多个进程被快速轮换执行（时间片轮换算法），宏观上有同时执行的效果（同一时间段内执行）。

现代的操作系统都支持多进程并发执行。

线程

线程（Thread）是执行特定任务的最小单位，是进程的执行单元，也被称为轻量级进程（Lightweight Process）。

一个进程至少有一个线程，也可以有多个线程。所谓多线程就是指同一个进程可以同时并发处理多个任务。

线程没有系统资源，多个线程共享其所属进程的系统资源，因此多线程运行时，需要处理好资源同步问题。

总结：

操作系统可以同时执行多个任务，每个任务是一个进程；
进程可以同时执行多个任务，每个任务是一个线程。

多线程的优点

多线程就是下图这种感觉：

对计算机来说，多线程可以提高CPU的利用率。

例如：网络的数据传输速率远低于计算机的处理能力，如果是单线程程序，在下载网络资源时，CPU需要花费大量的空闲时间来等待，而多线程能够利用这些空闲时间完成其他任务。

具体来说：

|--一个浏览器可以在下载的同时打开其他网页；

|--Web服务器可以同时相应多个用户请求；

|--QQ发送文件的时候还能跟其他人继续聊天……

当前线程

Thread.currentThread()：获取当前线程

.getName()：获取线程名称

public class TestMainThread {

	public static void main(String[] args) {

		// 获得当前运行的线程

		Thread tMain = Thread.currentThread();

		// 线程名称，优先级，线程组

		System.out.println("当前运行的线程是：" + tMain);

		System.out.println("线程名称：" + tMain.getName());

	}

}

当前运行的线程是：Thread[main,5,main]

线程名称：main

创建线程

方法1：继承Thread类

Thread类代表线程，所有的线程对象都是Thread类或其子类的对象。

创建线程的步骤：

继承Thread类
重写run()方法（线程执行体）
创建Thread类的实例对象
调用start()方法启动线程

可以使用setName(…)为线程设置名字，用getName()获取。

默认情况下，主线程名为main，子线程名为Thread-0、Thread-1等。

public class _11NewThread {

	public static void main(String[] args) {

		Thread t1 = new MyT();

		t1.setName("1");

		t1.start();

		Thread t2 = new MyT();

		t2.setName("   2");

		t2.start();

	}

}

class MyT extends Thread {

	@Override

	public void run() {

		for (int i = 0; i < 100; i++) {

			System.out.println("线程:" + super.getName());

		}

	}

}

方法2：实现Runnable接口

Runnable是个接口，实现Runnable接口的类还可以继承其它类，这是比方法1优越的地方。

实现Runable接口
重写run()方法
创建Runable对象
创建Thread对象
调用thread.start()方法，启动线程

实际创建的对象还是Thread实例。

public class _12NewThreadRunnable {

	public static void main(String[] args) {

		MyR r1 = new MyR("A");

		Thread t1 = new Thread(r1);

		t1.setName("XXX");

		t1.start();

		MyR r2 = new MyR("  B");

		Thread t2 = new Thread(r2);

		t2.start();

	}

}

class MyR implements Runnable {

	public MyR(String s) {

		this.s = s;

	}

	private String s;

	@Override

	public void run() {

		for (int i = 0; i < 100; i++) {

			System.out.println("线程:" + s);

		}

	}

}

*方法3：实现Callable接口

使用Callable和FutureTask创建线程——可以获取线程的返回值。这种做法了解即可。

实现Callable接口的线程，需重写call()方法，有返回值
需要FutureTask类包装一下Callablle，该类实现了Runable接口
以Future对象为参数创建线程，调用start()方法启动
以Futrue对象.get()接收返回值

package ahjava.p06thread;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

// 实现Callable接口的线程，需重写call()方法，有返回值

// 需要FutureTask类包装一下Callablle，该类实现了Runable接口

// 以Future对象为参数创建线程，调用start()方法启动

// 以Futrue对象.get()接收返回值

public class _13NewThreadCallable {

	public static void main(String[] args) {

		MyCallable _Callable = new MyCallable("A");

		FutureTask<String> _FutureTask = new FutureTask<>(_Callable);

		Thread _Thread = new Thread(_FutureTask);

		_Thread.start();

		try {

			// 模拟等待，此过程可看到子线程在执行

			Thread.sleep(3000);

		} catch (InterruptedException e1) {

			e1.printStackTrace();

		}

		// 接受子线程的返回值

		try {

			String s = _FutureTask.get();

			System.out.println("子线程的返回值 = " + s);

		} catch (InterruptedException | ExecutionException e) {

			e.printStackTrace();

		}

	}

}

class MyCallable implements Callable<String> {

	public MyCallable(String s) {

		this.s = s;

	}

	private String s;

	@Override

	public String call() throws Exception {

		for (int i = 0; i < 100; i++) {

			System.out.println("线程:" + s);

		}

		return "我是子线程，已经执行完毕";

	}

}

start()和run()

调用start()是开启新线程，调用run()是普通方法调用。

方法调用是入栈操作，调用完毕则出栈。

如果直接调用run()方法，则是在原线程中进行方法调用，用的还是之原线程的栈。

调用start()才是开启一个新线程，会创建新的栈。

线程的优先级


最高	10	Thread.MAX_PRIORITY
默认	5	Thread.NORM_PRIORITY
最低	1	Thread.MIN_PRIORITY

演示示例：

Thread(Runnable target, String name):为线程直接命名

Thread.currentThread():获取当前线程

public class Priority线程优先级 {

	// *可能不太容易看出来

	public static void main(String[] args) {

		MyRu r1 = new MyRu();

		MyRu r2 = new MyRu();

		MyRu r3 = new MyRu();

		Thread t1 = new Thread(r1);

		// 创建时命名

		Thread t2 = new Thread(r2, "   B");

		Thread t3 = new Thread(r3);

		t1.setName("A");

		t3.setName("       C");

		t1.setPriority(Thread.MAX_PRIORITY);

		t3.setPriority(Thread.MIN_PRIORITY);

		t1.start();

		t2.start();

		t3.start();

	}

}

class MyRu implements Runnable {

	@Override

	public void run() {

		String sName = Thread.currentThread().getName();

		int sPri = Thread.currentThread().getPriority();

		for (int i = 0; i < 100; i++) {

			System.out.println("线程:" + sName + " 优先级:" + sPri);

		}

	}

}

多线程的运行结果是不确定的，运行结果每次不同，可能有些时候看不出不同优先级的区别。

巴特西

Java基础教程——多线程：创建线程

多线程