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()方法，这样相当于普通调用对象的方法，并为启动线程）

继承类

publicclassMyThreadextendsThread{@Overridepublicvoidrun(){for(int i =1; i <=50; i++){System.out.println("子线程：==>"+ i);}}}

测试类

publicclassTestThread{publicstaticvoidmain(String[] args){MyThread myThread =newMyThread();
        myThread.start();for(int i =1; i <=50; i++){System.out.println("主线程：-->"+i);}}}

结果

获取线程ID和名称

getId()

//获取线程的id，每个线程都有自己的id

getName()

//获取线程名字

Thread.currentThread()

//获取当前线程

代码

publicclassTestThread{publicstaticvoidmain(String[] args){MyThread t=newMyThread();
        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()

方法

代码

publicclassMyThreadextendsThread{publicMyThread(){}//无参构造器publicMyThread(String name){super(name);}publicvoidrun(){for(int i=1;i<=50;i++){}}}

publicclassTestThread{publicstaticvoidmain(String[] args){MyThread t1=newMyThread("子线程1");//通过构造方法MyThread t2=newMyThread();
        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()

方法

实现接口

publicclassMyRunnableimplementsRunnable{//实现接口@Overridepublicvoidrun(){//实现run方法// TODO Auto-generated method stubfor(int i=1;i<=10;i++){System.out.println("子线程："+i);}}}

测试类

publicclassTestRunnable{publicstaticvoidmain(String[] args){//1.创建MyRunnable对象，表示线程执行的功能Runnable runnable=newMyRunnable();//2.创建线程对象Thread th=newThread(runnable);//3.启动线程
        th.start();for(int i=1;i<=10;i++){System.out.println("主线程："+i);}}}

使用匿名内部类

如果一个线程方法我们只使用一次，那么就不必设置一个单独的类，就可以使用匿名内部类实现该功能

publicclassTestRunnable{publicstaticvoidmain(String[] args){Runnable runnable=newRunnable(){@Overridepublicvoidrun(){// TODO Auto-generated method stubfor(int i=1;i<=10;i++){System.out.println("子线程："+ i);}}};Thread th=newThread(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方法看到：方法有返回值，可以抛出异常

具体实现

实现接口

importjava.util.Random;importjava.util.concurrent.Callable;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.FutureTask;publicclassTestCallableimplementsCallable<Integer>{@OverridepublicIntegercall()throwsException{// TODO Auto-generated method stubreturnnewRandom().nextInt(10);}}

测试类

importjava.util.concurrent.ExecutionException;importjava.util.concurrent.FutureTask;publicclassTest{publicstaticvoidmain(String[] args)throwsInterruptedException,ExecutionException{TestCallable tc=newTestCallable();FutureTask<Integer> ft=newFutureTask<>(tc);//创建线程对象Thread th=newThread(ft);
        th.start();//获取线程得到的返回值IntegerIn=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毫秒

子线程

publicclassSleepThreadextendsThread{@Overridepublicvoidrun(){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处理
测试类

publicclassTest01{publicstaticvoidmain(String[] args){SleepThread sleepThread =newSleepThread();
        sleepThread.start();}}

结果：每次间隔100ms输出一次

4.2 线程放弃（yield）

public static void yield()

当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片

子线程

publicclassYieldThreadextendsThread{@Overridepublicvoidrun(){for(int i=1;i<=10;i++){System.out.println(Thread.currentThread().getName()+":"+i);Thread.yield();//主动放弃资源}}}

测试类

publicclassTest01{publicstaticvoidmain(String[] args){YieldThread yieldThread01 =newYieldThread();YieldThread yieldThread02 =newYieldThread();
        yieldThread01.start();
        yieldThread02.start();}}

结果：基本都会交替进行，也会有一个线程连续输出

4.3 线程加入（join）

当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程，必须先start，再join才有效

子线程

publicclassJoinThreadextendsThread{@Overridepublicvoidrun(){for(int i=1;i<=10;i++){System.out.println(Thread.currentThread().getName()+":"+i);}}}

测试类

publicclassTest01{publicstaticvoidmain(String[] args)throwsInterruptedException{for(int i=1;i<=10;i++){System.out.println(Thread.currentThread().getName()+":"+i);if(i==5){JoinThread joinThread =newJoinThread();
                joinThread.start();
                joinThread.join();}}}}

结果：当主线程打印到5的时候，这时候子线程加入进来，就先执行完子线程，在执行主线程

4.4 守护线程（setDaemon）

将子线程设置为主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了
注意：先设置，在启动

子线程

publicclassTestThreadextendsThread{@Overridepublicvoidrun(){for(int i=1;i<=1000;i++){System.out.println(Thread.currentThread().getName()+":"+i);try{Thread.sleep(50);}catch(InterruptedException e){
                e.printStackTrace();}}}}

测试类

publicclassTest01{publicstaticvoidmain(String[] args)throwsInterruptedException{TestThread daemonThread =newTestThread();
        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机会越多

子线程

publicclassTestThreadextendsThread{@Overridepublicvoidrun(){for(int i=1;i<=100;i++){System.out.println(Thread.currentThread().getName()+":"+i);}}}

测试

publicclassTest01{publicstaticvoidmain(String[] args)throwsInterruptedException{TestThread th1 =newTestThread();TestThread th2 =newTestThread();TestThread th3 =newTestThread();
        th1.setPriority(10);//设置线程1优先级10
        th1.start();
        th2.start();//线程2优先级默认不变，为5
        th3.setPriority(1);//设置线程3优先级为1
        th3.start();}}

结果：优先级（th1>th2>th3）线程3应该在最后打印

五、线程安全问题

5.1 卖票案例

需求：模拟三个窗口，每个窗口有100个人，同时抢10张票

使用继承Runnable接口的方法

publicclassBuyTicketRunnableimplementsRunnable{privateint ticketNum=10;@Overridepublicvoidrun(){for(int i=1;i<=100;i++){if(ticketNum<=0)break;System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票！");
            ticketNum--;}}}

测试方法

publicclassBuyTicketTest{publicstaticvoidmain(String[] args){// TODO Auto-generated method stubRunnable runnable=newBuyTicketRunnable();Thread th1=newThread(runnable,"窗口1");Thread th2=newThread(runnable,"窗口2");Thread th3=newThread(runnable,"窗口3");
        
        th1.start();
        th2.start();
        th3.start();}}

结果

我们发现，不同窗口会抢到同一张票！！！，这在实际情况是不允许的，这是因为多个线程，在争抢资源的过程中，导致共享的资源出现问题。一个线程还没执行完，另一个线程就参与进来了，开始争抢。（但窗口2抢到第10张票，还没来得及

ticketNum--

操作，时间片就用完了，随后被窗口三抢到CPU资源，此时的票数还是10，窗口三也抢到第十张票，也还没来得及

ticketNum--

操作窗口三时间片由完了，窗口一抢到CPU资源，还是买到了第10张票）

多线程安全问题：

• 当多线程并发访问临界资源时，如果破坏原子操作，可能会造成数据不一致
• 临界资源：共享资源（同一对象），一次只能允许一个线程使用，才可以保证其正确性
• 原子操作：不可分割的多步操作，被视作一个整体，其顺序和步骤不可被打乱或缺省

5.2 同步代码块

synchronized

（同步监视器）

• 必须是引用数据类型，不能是基本数据类型
• 也可以创建一个专门的同步监视器，没有任何业务含义 （new Object）
• 一般使用共享资源做同步监视器即可
• 在同步代码块中不能改变同步监视器对象的引用
• 尽量不要String和包装类Integer做同步监视器，建议使用final修饰同步监视器

对卖票案例改进

publicclassBuyTicketRunnableimplementsRunnable{staticObject obj=newObject();privateint ticketNum=10;@Overridepublicvoidrun(){for(int i=1;i<100;i++){//把具有安全隐患的代码锁住即可，如果锁多了就会效率低 synchronized(obj){//锁必须多个线程用的是同一把锁！！也可以使用this，表示的是该对象本身System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票！");
                ticketNum--;}}}}

• 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块
• 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块， 但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块

5.3 同步方法

synchronized

（同步方法）

• 不要将run()定义为同步方法
• 非静态同步方法的同步监视器是this；静态同步方法（static）的同步监视器是 类名.class 字节码信息对象
• 同步代码块的效率要高于同步方法（原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部）
• 同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块

买票案例改进

publicclassBuyTicketRunnableimplementsRunnable{privateint ticketNum=10;@Overridepublicvoidrun(){for(int i=1;i<100;i++){BuyTicket();}}publicsynchronizedvoidBuyTicket(){//锁住的是：this，如果是静态方法：当前类.classif(ticketNum>0){System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票！");
            ticketNum--;}}}

5.4 Lock锁

Lock

锁：

• DK1.5后新增新一代的线程同步方式:Lock锁，与采用synchronized相比，lock可提供多种锁方案，更灵活
• synchronized是Java中的关键字，这个关键字的识别是靠JVM来识别完成的呀。是虚拟机级别的。 但是Lock锁是API级别的，提供了相应的接口和对应的实现类，这个方式更灵活，表现出来的性能优于之前的方式。

对买票案例改进

importjava.util.concurrent.locks.Lock;importjava.util.concurrent.locks.ReentrantLock;publicclassBuyTicketRunnableimplementsRunnable{privateint ticketNum=10;Lock lock=newReentrantLock();//接口=实现类  可以使用不同的实现类@Overridepublicvoidrun(){for(int i=1;i<100;i++){
            lock.lock();//打开锁try{if(ticketNum>0){System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票！");
                    ticketNum--;}}catch(Exception e){
                e.printStackTrace();}finally{//关闭锁：--->即使有异常，这个锁也可以得到释放
                lock.unlock();}}}}

Lock和synchronized的区别

• Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁
• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

5.5 线程死锁

• 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
• 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

*案例：男孩女孩一起去吃饭，但是桌子上只有两根筷子，如果两个人同时抢到一根筷子而不放弃，这样两个人都吃不上饭，这样就形成死锁了；必须要有一个人放弃争抢，等待另一个人用完，释放资源，这个人之后才会获得两根筷子，两个人才能都吃上饭 *

package 多线程;classEat{//代表两个筷子publicstaticObject o1=newObject();publicstaticObject o2=newObject();publicstaticvoideat(){System.out.println("可以吃饭了");}}classBoyThreadextendsThread{publicvoidrun(){synchronized(Eat.o1){System.out.println("男孩拿到了第一根筷子！");synchronized(Eat.o2){System.out.println("男孩拿到了第二根筷子！");Eat.eat();}}}}classGirlThreadextendsThread{publicvoidrun(){synchronized(Eat.o2){System.out.println("女孩拿到了第二根筷子！");synchronized(Eat.o1){System.out.println("女孩拿到了第一根筷子！");Eat.eat();}}}}publicclassMyLock{publicstaticvoidmain(String[] args){BoyThread boy=newBoyThread();GirlThread girl=newGirlThread();
        boy.start();
        girl.start();}}

结果

解决办法

先让男孩拿到筷子，线程休眠一下，等待男孩用完筷子，在启动女孩线程

publicclassMyLock{publicstaticvoidmain(String[] args){BoyThread boy=newBoyThread();GirlThread girl=newGirlThread();
        boy.start();try{Thread.sleep(100);}catch(InterruptedException e){// TODO Auto-generated catch block
            e.printStackTrace();}
        girl.start();}}

在写程序中要避免这种死锁：减少同步资源的定义，避免嵌套同步

六、线程通信问题

在Java对象中，有两种池

• 锁池（synchronized）
• 等待池（wait();notify();notifyAll()）

如果一个线程调用了某个对象的wait方法，那么该线程进入到该对象的等待池中（并且已经将锁释放）；
如果未来的某个时刻，另外一个线程调用了相同的对象notify方法或者notifyAll方法，那么该等待池中的线程就会被唤醒，然后进入到对象的锁池里面去获得该对象的锁；
如果获得锁成功后，那么该线程就会沿着wait方法之后的路径继续执行。注意：沿着wait方法之后执行

6.1 wait()和wait(long timeout)

• wait()：的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。直到其他线程调用此对象的notify() 方法或 notifyAll() 方法，当前线程被唤醒(进入就绪状态)
• wait(long timeout)：让当前线程处于“等待(阻塞)状态，直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入就绪状态)

sleep和wait的区别：sleep进入阻塞状态没有释放锁，wait进入阻塞状态但是同时释放了锁

6.2 notify()和notifyAll()

notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程

• notify()是唤醒单个线程
• notifyAll()是唤醒所有的线程

6.3 生产者和消费者问题

案例：
假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

功能分解一：商品类

publicclassProduct{//商品类privateString name;//名字privateString brand;//品牌boolean flag =false;//设置标记，false表示商品没有，等待生产者生产publicsynchronizedvoidsetProduct(String name,String brand){//生产商品，同步方法，锁住的是thisif(flag ==true){//如果flag为true，代表有商品，不生产，等待消费者消费try{wait();}catch(InterruptedException e){
                e.printStackTrace();}}//生产商品this.setName(name);this.setBrand(brand);System.out.println("生产者生产了"+this.getBrand()+this.getName());//生产完，设置标志
        flag =true;//唤醒消费线程notify();}publicsynchronizedvoidgetProduct(){if(flag ==false){//如果是false，则没有商品，等待生产者生产try{wait();}catch(InterruptedException e){
                e.printStackTrace();}}//如果有商品，消费System.out.println("消费者消费了"+this.getBrand()+this.getName());//设置标志
        flag =false;//唤醒线程notify();}publicvoidsetName(String name){this.name = name;}publicStringgetName(){return name;}publicvoidsetBrand(String brand){this.brand = brand;}publicStringgetBrand(){return brand;}}

功能分解二：生产者线程

publicclassProducterThreadextendsThread{//生产者线程privateProduct p;publicProducterThread(Product p){this.p = p;}@Overridepublicvoidrun(){for(int i =1; i <=10; i++){if(i%2==0){//如果是奇数，就生产巧克力，如果是偶数，就生产方便面
                p.setProduct("巧克力","德芙");}else{
                p.setProduct("方便面","康师傅");}}}}

功能分解三：消费者线程

publicclassCustomerThreadextendsThread{//消费者线程privateProduct pro;publicCustomerThread(Product pro){this.pro = pro;}@Overridepublicvoidrun(){for(int i =1; i <=10; i++){
            pro.getProduct();}}}

功能分解四：测试类

publicclassTest{publicstaticvoidmain(String[] args){Product p =newProduct();ProducterThread pth =newProducterThread(p);CustomerThread cth =newCustomerThread(p);
        pth.start();
        cth.start();}}

结果：生产者生产一件商品，消费者消费一件商品，交替进行