java 多线程例子(java多线程全面分析+代码示例)

之桃

2022-04-27 23:25:35

1.什么是进程？什么是线程？

进程是一个应用程序/软件。

线程是一个进程中的执行场景/执行单元

一个进程可以启动多个线程。

2.对于Java程序来说，当在DOS命令窗口中输入：

java hello world回车之后，会先启动JVM，而JVM就是一个进程。

JVM再启动一个主线程调用main方法。

同时再启动一个垃圾回收线程负责看护，回收垃圾。

最起码，现在的Java程序中至少有两个线程并发：

一个是垃圾回收线程，一个是执行main方法的主线程。

3.进程和线程是什么关系？举个例子

阿里巴巴：进程

马云：阿里巴巴的一个线程

童文红：阿里巴巴的一个线程

java 多线程

京东：进程

刘强东：京东的一个线程

奶茶妹妹：京东的一个线程

进程可以看作是现实生活当中的公司。

线程可以看作是公司当中的某个员工。

注意：进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不共享）

举个例子：魔兽游戏是一个进程，网易云音乐是一个进程。两个进程是独立的，不共享资源。

线程A和线程B呢？在Java语言中：线程A和线程B，堆内存和方法区内存共享。但是栈内存独立，一个线程一个栈。

假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。

火车站可以看成一个进程，每个售票窗口看成一个线程。我在1购票，你在2购票。互不用等，提高效率。Java中之所以有多线程机制，目的就是为了提高程序的处理效率。

4.思考一个问题：

使用了多线程机制之后，main方法结束，是不是有可能程序也没有结束，main方法结束了只是主线程结束了，主栈空了，其他的栈可能还在压栈，弹栈。

5.分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？

什么是真正的多线程并发？t1线程执行t1的，t2线程执行t2的，互不干涉。

单核CPU表示只有一个大脑：不能够做到真正的多线程并发，但是可以做到给人一种多线程并发的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的。处理速度极快，多个线程之间频繁切换执行，给人的感觉是多个事情同时在做。

6.Java语言中，实现线程的方式有两种。

Java支持多线程机制，并且Java已经将多线程实现了，我们继承就完事了。

第一种方式：编写一个类，直接继承Java.lang.Thread，重写run方法。

public class MyThread extends Thread{
public void run(){

}
}
MyThread t= new MyThread();
t.start();

第二种方法：编写一个类，实现java.lang.Runnable接口，实现run方法。

public class MyRunnable implements Runnable{
//定义一个可运行的类
public void run(){

}
//创建线程对象
Thread t=new Thread(new MyRunnable());
//启动线程
t.start();
}

7.第一种方式test

package Thread;
/*
* 实现线程的第一种方式：
* 编写一个类，直接继承Java.lang.Thread,重写run方法
*
* 怎么创建线程对象？ new就行了
* 怎么启动线程呢？调用线程对象的start()方法
*
* 注意：亘古不变的道理：
* 方法体中的代码永远都是自上而下的顺序依次逐行执行的。
*
* */
public class ThreadTest02 {
public static void main(String[] args) {
//这里是main方法，这里的代码属于主线程，在主栈中运行。
//新建一个分支线程对象
MyThread myThread=new MyThread();
//启动线程
//start（）方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，
// 这段代码完成任务后，瞬间就结束了。
//这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start方法就结束了。线程就启动成功了
//启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
//run方法在分支栈的栈底部，run和main是平级的。
myThread.start();

//这里的代码还是运行在主线程中
for (int i=0;i<1000;i++){
System.out.println("主线程--->"+i);
}

}

}
class MyThread extends Thread{
@Override
public void run(){
//编写程序，这段程序运行在分支线程中（分支栈）。
for (int i=0;i<1000;i++){
System.out.println("分支线程--->"+i);
}
}
}

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其他的类，更灵活。

8.匿名内部类的方式

package Thread;

/*
* 采用匿名内部类可以吗？
* */
public class ThreadTest04 {
public static void main(String[] args) {
//创建线程对象，采用匿名内部类方式
//这是一个通过没有名字的类，new出来的对象。
Thread t=new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i <1000 ; i++) {
System.out.println("分支-----"+i);
}
}
});
t.start();
for (int i = 0; i <1000 ; i++) {
System.out.println("主-----"+i);
}
}

}

9.线程生命周期

新建状态、就绪状态、运行状态、阻塞状态、死亡状态。

10.获取线程的名字

package Thread;

/*
*1.怎么获取当前线程对象？
* static Thread currentThread()
* Thread t=Thread.currentThread();
* 返回值t就是当前线程。
* 2.获取线程对象的名字 t.getName()
*3.修改线程对象的名字 t.setName("线程名字")
* 默认名字为Thread-0 Thread-1
* */
public class ThreadTest05 {
public static void main(String[] args) {

//这个代码出现在主线程中，所以当前线程就是主线程
Thread currentThread=Thread.currentThread();
System.out.println(currentThread.getName());

//创建线程对象
MyThread2 t=new MyThread2();
//设置线程名字
// t.setName("ttt");
//获取线程名字
System.out.println(t.getName());//默认为Thread-0
//启动线程
t.start();
MyThread2 t2=new MyThread2();
System.out.println(t2.getName());

}
}
class MyThread2 extends Thread{
public void run(){
Thread currentThread=Thread.currentThread();
System.out.println(currentThread.getName());
for (int i = 0; i < 100; i++) {
System.out.println("分支"+i);
}
}
}

11.线程的sleep方法

package Thread;

/*
* Thread的sleep()方法
* static void sleep(long millis)
* 1.静态方法
* 2.参数是毫秒
* 3.作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它的线程使用。
* 出现在哪里，让对应的thread进入休眠。
* 4.Thread.sleep 方法可以做到这样的效果：
* 间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。
* */
public class ThreadTest06 {
public static void main(String[] args) throws InterruptedException {

//让当前线程进行睡眠，睡眠五秒钟
/*Thread.sleep(1000*5);
System.out.println("hello world！");*/
for (int i = 0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+"---"+i);
Thread.sleep(1000);
}
}
}

12.sleep方法的面试题

package Thread;
/*
* 关于Thread.sleep()方法的一个面试题：
* */
public class ThreadTest07 {
public static void main(String[] args) throws InterruptedException {
Thread t=new MyThread3();
t.setName("t");
t.start();
//问题：这行代码会让线程t进入休眠状态吗？
//

t.sleep(1000*5);//这段代码执行的时候还是会转换成：Thread.sleep(1000*5);
//这段代码的作用是让当前线程进入休眠,也就是说让main方法进入休眠
System.out.println("hello world");
}

}
class MyThread3 extends Thread{
public void run(){
for (int i = 0; i <10000 ; i++) {
System.out.println(Thread.currentThread().getName()+"---"+i);
}
}
}

13.终止线程睡眠

package Thread;
/*
* sleep睡眠时间太久了，如果希望半道上醒来，你应该怎么办？也就是说怎么叫醒一个正在睡眠的线程
* 注意：这个不是终端线程的执行，是终止线程的睡眠。
* */
public class ThreadTest08 {
public static void main(String[] args) throws InterruptedException {
Thread t=new Thread(new MyRunnable());
t.setName("t");
t.start();
//希望五秒之后，t线程醒来
Thread.sleep(1000*5);
//中断t线程的睡眠(这种中断睡眠的方式依靠的是Java的异常处理机制。)
t.interrupt();
}

}
class MyRunnable implements Runnable{

//run方法中的异常不可以throws，只可以try-catch，
//因为run方法在父类中没有抛出任何异常，子类不可以比父类抛出更多的异常
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--->begin");
try {
Thread.sleep(1000*60*60*24*365);//这里不可以throws，子类重写不能抛出更多的异常
} catch (InterruptedException e) {
e.printStackTrace();//打印信息
}
System.out.println(Thread.currentThread().getName()+"--->end ");
}
}

14.强行终止线程的进行

package Thread;
/*
* 在java中怎么强行终止一个线程。
*
*
* */
public class ThreadTest09 {
public static void main(String[] args) throws InterruptedException {
Thread t=new Thread(new MyRunnable3());
t.setName("t");
t.start();
//模拟5秒
Thread.sleep(1000*5);
//5秒后强制终止t线程
t.stop();//已经过时，不建议使用。
//缺点：会丢失数据！因为这种方式是直接将线程杀死，线程没有保存的数据将会丢失，不建议使用。

}

}
class MyRunnable3 implements Runnable{

@Override
public void run() {

for (int i = 0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}
}

15.合理的终止一个线程

package Thread;
/*
* 怎么合理的终止一个线程的执行，这种方法是很常见的
*
* */
public class ThreadTest10 {
public static void main(String[] args) throws InterruptedException {
MyRunnable4 myRunnable4= new MyRunnable4()
Thread t=new Thread(myRunnable4);
t.setName("t");
t.start();
//模拟五秒
Thread.sleep(1000*5);
//终止线程
// 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
myRunnable4.run=false;
}
}
class MyRunnable4 implements Runnable{

boolean run =true;
@Override
public void run() {
for (int i = 0; i <10 ; i++) {
if (run) {
System.out.println(Thread.currentThread().getName() + "---->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
//return就结束了。你在结束之前还有什么没保存的，在这里可以保存呀
//终止线程
return;
}
}
}
}

16.线程调度（概念了解）

常见的线程调度模型有哪些？

1.抢占式调度模型

哪个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些，Java采用的就是抢占式调度模型。

2.均分式调度模型

平均分配CPU时间片，每个线程占有的CPU时间片时间长度一样。平均分配，一切平等。有一些编程语言，线程调度模型采用的就是这种方式。

Java中提供了哪写方法是和线程调度有关系的呢？

实例方法：void setPriority (int newPriority)设置线程优先级

int getPriority()获取线程优先级

最低优先级是1，默认优先级是5，最高优先级是10。优先级比较高的获取CPU时间片可能会多一些（但也不完全，大概率是多的）。

void join()合并线程

静态方法：static void yield()让位方法：暂停当前正在执行的线程对象，并执行其他线程。yield方法不是阻塞方法。让当前线程让位，让给其他线程使用，yield方法的执行会让当前线程从“运行状态”回到“就绪状态”。注意：在回到就绪之后，有可能会再次抢到。

17.线程优先级

package Thread;
/**
* 了解：关于线程优先级
*/

public class ThreadTestd11 {
public static void main(String[] args) {
/* System.out.println("最高优先级"+Thread.MAX_PRIORITY);
System.out.println("最低优先级"+Thread.MIN_PRIORITY);
System.out.println("默认优先级"+Thread.NORM_PRIORITY);*/
//获取当前线程对象，获取当前线程的优先级
Thread currentThread=Thread.currentThread();
System.out.println(currentThread.getName()+"线程的默认优先级："+currentThread.getPriority());

Thread t=new Thread(new MyRunnable5());
t.setName("t");
t.start();

}
}
class MyRunnable5 implements Runnable{

@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"默认优先级"+Thread.currentThread().getPriority());
}
}

18.线程让位

package Thread;
/*
* 让位：当前线程暂停，回到就绪状态，让给其他线程。
* 静态方法：Thread yield()
* */
public class ThreadTest12 {
public static void main(String[] args) {
Thread t=new Thread(new MyRunnable6());
t.setName("t");
t.start();
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}

}
class MyRunnable6 implements Runnable{

@Override
public void run() {
//每一百个让位一次

for (int i = 0; i < 1000; i++) {
if(i%100==0){
Thread.yield();
}

System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}

19.线程合并

package Thread;

public class ThreadTest13 {
public static void main(String[] args) throws InterruptedException {
System.out.println("main begin");
Thread t=new Thread(new MyRunnbable7());
t.setName("t");
t.start();

//合并线程：栈之间协调
t.join();//t合并到当前线程，当前线程受阻塞，t线程执行直到结束
System.out.println("main over");
}

}
class MyRunnbable7 implements Runnable{
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
}
}
}

20.线程安全（数据安全问题）

为什么这个是重点？

以后再开发中，我们的项目都是运行在服务器当中的，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。

最重要的是：你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。

什么情况下数据在多线程并发的环境下会存在安全问题呢？

三个条件：1.多线程并发 2.有共享数据 3.共享数据有修改的行为

满足以上三个条件之后，就会存在线程安全问题。

怎么解决线程安全问题呢？

线程排队执行（不能并发）。用排队执行解决线程安全问题

这种机制被称为：线程同步机制。实际上就是排队

线程会失去牺牲一部分效率，没办法，数据安全第一位。只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事。（并发虽然效率高，但是有时候会不安全）

异步编程模型：线程t1和线程t2，各自执行各自的。

同步编程模型：线程t1和线程t2，在线程t1执行的时候，必须等待线程t2执行结束。两个线程之间发生了等待关系。

银行取款例子

package ThreadSafe2;

//银行账户
//使用线程同步解决线程安全问题
public class Account {

//账号
private String actno;
//余额
private double balance;

public Account() {
}

public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}

public String getActno() {
return actno;
}

public void setActno(String actno) {
this.actno = actno;
}

public double getBalance() {
return balance;
}

public void setBalance(double balance) {
this.balance = balance;
}

//取款方法
public void withdraw(double money) throws InterruptedException {

//以下这些代码必须是线程排队的,不能并发
//一个线程把这里的代码全部执行结束之后,另一个线程才可以进来.

/*
* 线程同步机制的语法是:
* synchronized(){
* //线程同步代码块
* }
* synchronized()后面小括号传入的数据是相当关键的,这个数据必须是多线程共享的数据.才能达到多线程排队
* 小括号中写什么?
* 那要看你想让哪些线程同步
* 假设t1,t2,t3,t4,t5 五个线程
* 你只希望t1,t2,t3排队,t4,t5不排队,怎么办?
* 你一定要在()中写一个t1,t2,t3共享的对象,而这个对象对于t4,t5来说是不共享的
*
* 这里的共享对象是账户对象.账户对象是共享的,那么this就是账户对象
* 这里不一定是this,这里只要是多线程共享的那个对象就行
* 在Java语言中，任何一个对象都有一把锁，这把锁就是一个标记。
* 100个对象，100把锁
* */
synchronized (this){
double before=this.getBalance();
double after=before-money;
Thread.sleep(1000);
this.setBalance(after);
}
}
}
public class AccountThread extends Thread {
//两个线程必须共享同一个线程对象.

private Account act;

//通过构造方法传递过来账户对象.
public AccountThread(Account act){
this.act=act;
}
public void run(){

//run方法的执行表示取款操作。
double money=5000;
//取款
try {
act.withdraw(money);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"对"+act.getActno()+"取款成功!余额为:"+act.getBalance());
}
}

public class Test {
public static void main(String[] args) {
//创建账户对象(只创建一个)
Account account=new Account("act--01",10000);
Thread t1=new AccountThread(account);
Thread t2=new AccountThread(account);
t1.setName("T1");
t2.setName("T2");
t1.start();
t2.start();
}
}

21.哪些变量有线程安全问题

Java中有三大变量

实例变量：在堆中

静态变量：在方法区中

局部变量：在栈中永远不会存在线程安全问题！因为局部变量不共享

如果使用局部变量的话：建议使用StringBuilder。因为局部变量不存在线程安全问题。选择StringBuilder。StringBuffer 效率比较低。

ArrayList是非线程安全的，Vector是线程安全的。HashMap HashSet是非线程安全的。Hashtable是线程安全的。

总结：synchronized有三种写法：

第一种：同步代码块：灵活

第二种：在实例方法上使用synchronized，表示共享对象是一个this，并且同步代码块是整个方法体。

第三种：在静态方法上使用synchronized，表示找类锁，类锁永远只有一把，一百个对象也只有一把。

22.死锁

死锁代码例子

package DeadLock;
/*
* 死锁代码要会写,一般面试官要求你会写.
* 只有会写,才会在以后的开发中注意这个事.
* 因为死锁很难调试
* */
public class deadlock {
public static void main(String[] args) {
Object o1=new Object();
Object o2=new Object();
//t1和t2两个线程共享o1,o2
Thread t1=new MyThread1(o1,o2);
Thread t2=new MyThread2(o1,o2);
t1.start();
t2.start();
}

}
class MyThread1 extends Thread{
Object o1;
Object o2;
public MyThread1(Object o1,Object o2){
this.o1=o1;
this.o2=o2;
}
public void run(){
synchronized (o1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2){
}
}
}
}
class MyThread2 extends Thread{
Object o1;
Object o2;
public MyThread2(Object o1,Object o2){
this.o1=o1;
this.o2=o2;
}
public void run(){
synchronized (o2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1){
}
}
}
}

如何解决线程安全问题？一上来就synchronized？

不是的，synchronized会让程序的执行效率降低，用户体验差，系统的用户吞吐量降低，用户体验差，在不得已的情况下再选择线程同步机制。

第一种方案：尽量使用局部变量来代替实例变量和静态变量

第二种方案：如果必须得是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了（一个线程一个对象）。

第三种方案：如果不能使用局部变量，对象也不可以创建多个。这时只可以选择synchronized

23.守护线程

Java语言中线程分为两大类：

一类是：用户现场

一类是：守护线程（后台线程）代表性：垃圾回收线程

守护线程的特点：

一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。

注意：主线程main方法是一个用户线程。

守护线程用在什么地方？

每天0：00的时候系统的数据自动备份，这个需要使用定时器，并且我们可以将定时器设置为守护线程。一直在那里看着，每到0：00的时间就备份一次，所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。

package Thread;
/*
* 实现守护线程
* */
public class ThreadTest14 {
public static void main(String[] args) throws InterruptedException {
Thread t=new BakDataThread();
t.setName("备份数据线程");
//启动线程之前,将线程设置为守护线程
t.setDaemon(true);
t.start();

//主线程:主线程是用户线程
for (int i = 0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
Thread.sleep(1000);
}
}
}
class BakDataThread extends Thread{
public void run(){
int i=0;
//即使是死循环,但由于该线程是守护线程,当用户线程终止时,守护线程也会停止
while (true){
System.out.println(Thread.currentThread().getName()+"--->"+(++i));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

24.定时器

定时器的作用：间隔特点的时间，执行特定的程序。

如：每周要进行银行账户的总账操作。每天要进行数据的备份操作。

在实际的开发过程中，每隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种方式实现：

可以使用sleep方法，睡眠，设置睡眠时间，每到特定时间醒来，这样的方式是最原始的定时器。

在java类库中已经写好了一个定时器，java.util.Timer,可以直接用。不过这样的方式在目前开发中也不怎么用，因为现在的很多高级框架都是支持定时任务的，在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

package Thread;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/*
*使用定时器指定定时任务
* */
public class TimerTest {

public static void main(String[] args) throws Exception{
//创建定时器对象
Timer timer=new Timer();
//Timer timer=new Timer(true);守护线程的方式

//指定定时任务
//schedule(定时任务,第一次执行时间,间隔多久执行一次);
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date firsttime=sdf.parse("2022-04-27 18:23:30");
timer.schedule(new LogTimeTask(),firsttime,1000*10);
/*timer.schedule(new TimerTask(){
匿名内部类也可以
@Override
public void run() {

}
},firsttime,1000*10);*/
}
}
//编写一个定时任务类
class LogTimeTask extends TimerTask{

@Override
public void run() {
//编写你需要执行的任务就行了
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ");
String strTime=sdf.format(new Date());
System.out.println(strTime+"完成了一次数据备份");
}
}

25.实现线程的第三种方式

实现Callable接口。（JDK新特性）

这种方式实现的线程可以获取线程的返回值，之前讲解的那两种方法无法获取线程的返回值的，因为run方法返回void。

思考：系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么拿到这个执行结果呢？使用第三种方式：实现Callable接口方式

package Thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/*
* 实现线程的第三种方式：实现callable接口
*
* */
public class ThreadTest15 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//第一步：创建一个“未来任务类”对象
//参数非常重要，需要给一个Callable接口实现类对象。
FutureTask task=new FutureTask(new Callable() {
//call方法相当于run方法，只不过call有返回值
//线程执行一个任务，执行之后可能会有一个执行结果
//模拟执行
@Override
public Object call() throws Exception {
System.out.println(" call method begin");
Thread.sleep(1000*10);
System.out.println("call method end");
int a=100,b=200;
return a+b;//自动装箱（300为integer）
}
});
Thread t=new Thread(task);
t.start();
//这里是main方法，在主线程中，在主线程中怎么获取t的执行结果。
//get方法的执行会导致当前线程阻塞，
Object obj= task.get();
System.out.println("线程执行结果："+obj);
//main方法这里的程序要想执行必须等待get（）方法的结束。
//而get方法可能需要执行很久，因为get方法是为了拿另一个线程的执行结果，而另一个线程执行是需要时间的。

System.out.println("hello world");
}
}