再学Java -- 多线程（一）-CSDN博客

本文链接：https://blog.csdn.net/dzc18296226695/article/details/115841837

线程

简单概念
线程的创建和使用
线程的生命周期
- 1、新建和就绪状态

简单概念

进程和线程的区别

进程：当一个程序进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。

线程：线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量，但不拥有系统资源，它与父进程的其他线程共享该进程所拥有的全部资源。

多线程的优势：

进程之间不能共享内存，但线程之间共享内存非常容易
系统创建进程时需要为其重新分配系统资源，但创建线程代价小得多，因此使用多线程来实现多任务并发比多进程的效率高。

线程的创建和使用

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