线程
简单概念
进程和线程的区别
进程:当一个程序进入内存运行时,即变成一个进程。进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位。
线程:线程是进程的组成部分,一个进程可以拥有多个线程,一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量,但不拥有系统资源,它与父进程的其他线程共享该进程所拥有的全部资源。
多线程的优势:
- 进程之间不能共享内存,但线程之间共享内存非常容易
- 系统创建进程时需要为其重新分配系统资源,但创建线程代价小得多,因此使用多线程来实现多任务并发比多进程的效率高。
线程的创建和使用
1、继承Thread类创建线程
此种方式创建的线程不能共享实例变量值
package cn.zack.第十六章;
// 通过继承Thread类来创建线程类
public class FirstThread extends Thread
{
private int i ;
// 重写run方法,run方法的方法体就是线程执行体
@Override
public void run()
{
for ( ; i < 10 ; i++ )
{
// 当线程类继承Thread类时,直接使用this即可获取当前线程
// Thread对象的getName()返回当前该线程的名字
// 因此可以直接调用getName()方法返回当前线程的名
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args)
{
for (int i = 0; i < 10; i++)
{
// 调用Thread的currentThread方法获取当前线程
System.out.println(Thread.currentThread().getName()
+ " " + i);
if (i == 2)
{
// 创建、并启动第一条线程
new FirstThread().start();
// 创建、并启动第二条线程
new FirstThread().start();
}
}
}
}
main 0
main 1
main 2
Thread-0 0
main 3
main 4
Thread-0 1
main 5
Thread-1 0
main 6
Thread-0 2
main 7
Thread-1 1
main 8
Thread-0 3
Thread-0 4
Thread-0 5
Thread-0 6
Thread-0 7
Thread-0 8
Thread-0 9
main 9
Thread-1 2
Thread-1 3
Thread-1 4
Thread-1 5
Thread-1 6
Thread-1 7
Thread-1 8
Thread-1 9
从运行结果可以看到,一开始只有main的主线程在运行,当循环i到2的时候,创建2个子线程,子线程互不干扰,输出自己的变量值
可以看到多运行几次,输出的结果会变化, 是因为线程这个时候在start后是就绪状态,没有真正开始执行run,这由系统控制具有随机性。
如果想让主线程在2的时候立即执行子线程,则让其sleep一会就行
2、实现Runnable接口创建线程类
此种方式创建的多个线程可以共享变量值
package cn.zack.第十六章;
// 通过实现Runnable接口来创建线程类
public class SecondThread implements Runnable
{
private int i ;
// run方法同样是线程执行体
@Override
public void run()
{
for ( ; i < 10 ; i++ )
{
// 当线程类实现Runnable接口时,
// 如果想获取当前线程,只能用Thread.currentThread()方法。
System.out.println(Thread.currentThread().getName()
+ " " + i);
}
}
public static void main(String[] args)
{
for (int i = 0; i < 10; i++)
{
// System.out.println(Thread.currentThread().getName()
// + " " + i);
if (i == 2)
{
SecondThread st = new SecondThread(); // ①
// 通过new Thread(target , name)方法创建新线程
new Thread(st , "新线程1").start();
new Thread(st , "新线程2").start();
}
}
}
}
运行结果:
新线程2 0
新线程2 1
新线程1 0
新线程1 3
新线程2 2
新线程1 4
新线程1 6
新线程2 5
新线程1 7
新线程2 8
新线程1 9
Process finished with exit code 0
3、使用Callable和Future创建线程
package cn.zack.第十六章;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class ThirdThread implements Callable {
public static void main(String[] args) {
// 创建Callable对象
ThirdThread rt = new ThirdThread();
// 先使用Lambda表达式创建Callable<Integer>对象
// 使用FutureTask来包装Callable对象
//需要一个FutureTask,而且在两个线程里传入同一个futureTask,只会执行一次
FutureTask<Integer> futureTask = new FutureTask<>(rt);
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()
+ " 的循环变量i的值:" + i);
if (i == 2) {
// 实质还是以Callable对象来创建、并启动线程
new Thread(futureTask, "有返回值的线程").start();
}
}
try
{
// 获取线程返回值
System.out.println("子线程的返回值:" + futureTask.get());
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
@Override
public Object call() throws Exception {
int i = 0;
for (; i < 9; i++) {
System.out.println(Thread.currentThread().getName()
+ " 的循环变量i的值:" + i);
}
// call()方法可以有返回值
return i;
}
}
运行结果:
main 的循环变量i的值:0
main 的循环变量i的值:1
main 的循环变量i的值:2
main 的循环变量i的值:3
main 的循环变量i的值:4
main 的循环变量i的值:5
有返回值的线程 的循环变量i的值:0
main 的循环变量i的值:6
有返回值的线程 的循环变量i的值:1
main 的循环变量i的值:7
有返回值的线程 的循环变量i的值:2
main 的循环变量i的值:8
有返回值的线程 的循环变量i的值:3
有返回值的线程 的循环变量i的值:4
main 的循环变量i的值:9
有返回值的线程 的循环变量i的值:5
有返回值的线程 的循环变量i的值:6
有返回值的线程 的循环变量i的值:7
有返回值的线程 的循环变量i的值:8
子线程的返回值:9
相比于Runnable接口实现线程,这个方式多了try catch返回值
总结:创建线程的三种方式对比
方式 | 优缺点 |
---|---|
Thread | 优点:方便快捷,编写简单访问当前线程用this, 缺点:没法继承别的类 |
Runnable Callable | 优点:还可以继承别的类,数据共享 缺点:编写复杂 |
线程的生命周期
当线程被创建并启动后,他既不是一启动就进入了执行状态,也不是一直处于执行状态,在线程生命周期中,它要经过:
新建(New)、就绪(Runnable)运行(Running)、阻塞(Blocked)、死亡(Dead)
1、新建和就绪状态
package cn.zack.第十六章;
public class InvokeRun extends Thread
{
private int i ;
// 重写run方法,run方法的方法体就是线程执行体
@Override
public void run()
{
for ( ; i < 10 ; i++ )
{
// 直接调用run方法时,Thread的this.getName返回的是该对象名字,
// 而不是当前线程的名字。
// 使用Thread.currentThread().getName()总是获取当前线程名字
System.out.println(Thread.currentThread().getName()
+ " " + i); // ①
}
}
public static void main(String[] args)
{
for (int i = 0; i < 10; i++)
{
// 调用Thread的currentThread方法获取当前线程
System.out.println(Thread.currentThread().getName()
+ " " + i);
if (i == 2)
{
// 直接调用线程对象的run方法,
// 系统会把线程对象当成普通对象,run方法当成普通方法,
// 所以下面两行代码并不会启动两条线程,而是依次执行两个run方法
new InvokeRun().run();
new InvokeRun().run();
}
}
}
}
运行结果:
main 0
main 1
main 2
main 0
main 1
main 2
main 3
main 4
main 5
main 6
main 7
main 8
main 9
main 0
main 1
main 2
main 3
main 4
main 5
main 6
main 7
main 8
main 9
main 3
main 4
main 5
main 6
main 7
main 8
main 9
直接执行run方法不会去新建线程, 相当于单线程了
且需要注意:当调用过run后,不要再次调用start,不然会报错。即只能对新建的线程调用start