Java多线程（详细了解java多线程机制）
Posted Tangable1024
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java多线程（详细了解java多线程机制）相关的知识，希望对你有一定的参考价值。
每天进步一点点
一、程序、进程、线程
1.1 什么是程序
程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码。 （程序是静态的）
1.2 什么是进程
进程(process)：是程序的一次执行过程，正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。 （进程是动态的）是一个动的过程 ，进程的生命周期 : 有它自身的产生、存在和消亡的过程
目前操作系统都是支持多进程，可以同时执行多个进程，通过进程ID区分
1.3 什么是线程
线程(thread)：进程中的一条执行路径，也是CUP的基本调度单位，一个进程由一个或多个线程组成，彼此间完成不同的工作，多个线程同时执行，称为多线程。
线程的组成
任何一个线程都具有的基本组成部分：
- CPU时间片：操作系统（OS）会为每一个线程分配执行时间。
- 运行数据：堆空间（存储线程需要使用的对象，多个线程可以共享堆中的对象）；栈空间（存储线程需要使用的局部变量，每个线程都拥有独立的栈）
线程的特点
- 线程抢占式执行（效率高、可防止单一线程长时间独占CPU）
- 单核CPU在执行的时候，是按照时间片执行的，一个时间片只能执行一个线程，因为时间片特别的短，我们感受到的就是“同时”进行的。
- 多核CPU真正意义上做到了一个时间片多个线程同时进行
- 在单核CPU中，宏观上同时进行，微观上顺序执行
1.4 进程和线程的区别
- 进程是操作系统中资源分配的基本单位，而线程是CPU的基本调度单位
- 一个程序运行后至少有一个进程
- 一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义的
- 进程间不能共享数据段地址，但通进程的线程之间可以。
二、创建线程的三种方式
2.1 继承Thread类重写run()方法
具体实现
1.继承Thread类
2.重写run()方法
3.创建子类对象
4.调用start()方法（PS：不要调用run()方法，这样相当于普通调用对象的方法，并为启动线程）
继承类
public class MyThread extends Thread
@Override
public void run()
for (int i = 1; i <= 50; i++)
System.out.println("子线程：==>" + i);
测试类
public class TestThread
public static void main(String[] args)
MyThread myThread = new MyThread();
myThread.start();
for (int i = 1; i <= 50; i++)
System.out.println("主线程：-->"+i);
结果
获取线程ID和名称
getId()//获取线程的id，每个线程都有自己的id
getName()//获取线程名字
Thread.currentThread()//获取当前线程
代码
public class TestThread
public static void main(String[] args)
MyThread t=new MyThread();
t.start();
//只能在继承Thread类的情况下用
System.out.println("线程id:"+t.getId());
System.out.println("线程名字:"+t.getName());
//调用Thread类的静态方法获取当前线程（这里获取的是主线程）
System.out.println("线程id:"+Thread.currentThread().getId());
System.out.println("线程名字:"+Thread.currentThread().getName());
修改线程名称
只能修改线程的名称，不能修改线程的id（id是由系统自动分配）
1、使用线程子类的构造方法赋值
2、调用线程对象的setName()方法
代码
public class MyThread extends Thread
public MyThread() //无参构造器
public MyThread(String name)
super(name);
public void run()
for(int i=1;i<=50;i++)
public class TestThread
public static void main(String[] args)
MyThread t1=new MyThread("子线程1");//通过构造方法
MyThread t2=new MyThread();
t2.setName("子线程2");
System.out.println("线程t1的id："+t1.getId()+" 名称："+t1.getName());
System.out.println("线程t2的id："+t2.getId()+" 名称："+t2.getName());
2.2 实现Runnable接口实现run()方法
具体实现
1.实现
Runnable接口
2.实现run()方法
3.创建实现类对象
4.创建线程类对象
5.调用start()方法
实现接口
public class MyRunnable implements Runnable//实现接口
@Override
public void run() //实现run方法
// TODO Auto-generated method stub
for(int i=1;i<=10;i++)
System.out.println("子线程："+i);
测试类
public class TestRunnable
public static void main(String[] args)
//1.创建MyRunnable对象，表示线程执行的功能
Runnable runnable=new MyRunnable();
//2.创建线程对象
Thread th=new Thread(runnable);
//3.启动线程
th.start();
for(int i=1;i<=10;i++)
System.out.println("主线程："+i);
使用匿名内部类
如果一个线程方法我们只使用一次，那么就不必设置一个单独的类，就可以使用匿名内部类实现该功能
public class TestRunnable
public static void main(String[] args)
Runnable runnable=new Runnable()
@Override
public void run()
// TODO Auto-generated method stub
for(int i=1;i<=10;i++)
System.out.println("子线程："+ i);
;
Thread th=new Thread(runnable);
th.start();
2.3 实现Callable接口
Callable和Thread、Runnable比较
对比继承
Thread类和实现Runnable接口创建线程的方式发现，都需要有一个run()方法，但是这个run()方法有不足：
- 没有返回值
- 不能抛出异常
基于上面的两个不足，在JDK1.5以后出现了第三种创建线程的方式：实现
Callable接口实现
Callable接口的好处：
- 有返回值
- 能抛出异常
缺点：
- 创建线程比较麻烦
1.实现
Callable接口，可以不带泛型，如果不带泛型，那么call方法的返回值就是Object类型2.如果带泛型，那么call的返回值就是泛型对应的类型
3.从call方法看到：方法有返回值，可以抛出异常
具体实现
实现接口
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class TestCallable implements Callable<Integer>
@Override
public Integer call() throws Exception
// TODO Auto-generated method stub
return new Random().nextInt(10);
测试类
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test
public static void main(String[] args) throws InterruptedException, ExecutionException
TestCallable tc=new TestCallable();
FutureTask<Integer> ft=new FutureTask<>(tc);
//创建线程对象
Thread th=new Thread(ft);
th.start();
//获取线程得到的返回值
Integer In=ft.get();
System.out.println(In);
三、线程的状态
3.1 基本四状态
3.2 等待状态
3.3 阻塞状态
四、线程常用的方法
休眠（当前线程主动休眠millis毫秒）
public static void sleep(long millis)放弃（当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片）
public static void yield()加入（当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程）
public final void join()//必须先start()，在join()，才有效优先级（线程优先级为1–10，默认为5，优先级越高，表示获取CPU机会越多）
线程对象.setPriority()守护线程
- 线程对象.setDaemon(true)；设置为守护线程
- 线程有两类：用户线程（前台线程）、守护线程（后台线程）
- 如果程序中所有前台线程都执行完毕了，后台线程也会自动结束
- 垃圾回收器线程属于守护线程
4.1 线程休眠（sleep）
public static void sleep(long millis)当前线程主动休眠millis毫秒
子线程
public class SleepThread extends Thread
@Override
public void run()
for (int i = 1; i <= 10; i++)
System.out.println(Thread.currentThread().getName()+"："+i);
try
Thread.sleep(100);
catch (InterruptedException e)
e.printStackTrace();
PS：sleep()的异常在run方法中是不能抛出的，只能用try–catch处理
测试类
public class Test01
public static void main(String[] args)
SleepThread sleepThread = new SleepThread();
sleepThread.start();
结果：每次间隔100ms输出一次
4.2 线程放弃（yield）
public static void yield()当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片
子线程
public class YieldThread extends Thread
@Override
public void run()
for (int i=1;i<=10;i++)
System.out.println(Thread.currentThread().getName()+":"+i);
Thread.yield();//主动放弃资源
测试类
public class Test01
public static void main(String[] args)
YieldThread yieldThread01 = new YieldThread();
YieldThread yieldThread02 = new YieldThread();
yieldThread01.start();
yieldThread02.start();
结果：基本都会交替进行，也会有一个线程连续输出
4.3 线程加入（join）
当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程，必须先start，再join才有效
子线程
public class JoinThread extends Thread
@Override
public void run()
for (int i=1;i<=10;i++)
System.out.println(Thread.currentThread().getName()+":"+i);
测试类
public class Test01
public static void main(String[] args) throws InterruptedException
for (int i=1;i<=10;i++)
System.out.println(Thread.currentThread().getName()+":"+i);
if(i==5)
JoinThread joinThread = new JoinThread();
joinThread.start();
joinThread.join();
结果：当主线程打印到5的时候，这时候子线程加入进来，就先执行完子线程，在执行主线程
4.4 守护线程（setDaemon）
将子线程设置为主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了
注意：先设置，在启动
子线程
public class TestThread extends Thread
@Override
public void run()
for(int i=1;i<=1000;i++)
System.out.println(Thread.currentThread().getName()+":"+i);
try
Thread.sleep(50);
catch (InterruptedException e)
e.printStackTrace();
测试类
public class Test01
public static void main(String[] args) throws InterruptedException
TestThread daemonThread = new TestThread();
daemonThread.setDaemon(true);//设置守护线程
daemonThread.start();
for (int i=1;i<=10;i++)
System.out.println(Thread.currentThread().getName()+":"+i);
Thread.sleep(100);
结果：当主线程结束时，子线程也跟着结束，并不会继续执行下去打印输出
4.5 线程优先级（setPriority）
线程优先级为1-10，默认为5，优先级越高，表示获取CPU机会越多
子线程
public class TestThread extends Thread
@Override
public void run()
for(int i=1;i<=100;i++)
System.out.println(Thread.currentThread().getName()+":"+i);
测试
public class Test01
public static void main(String[] args) throws InterruptedException
TestThread th1 = new TestThread();
TestThread th2 = new TestThread();
TestThread th3 = new TestThread();
th1.setPriority以上是关于Java多线程（详细了解java多线程机制）的主要内容，如果未能解决你的问题，请参考以下文章