Java多线程-阿里云开发者社区

一、程序、进程、线程的概念

程序：指令的有序集合，即一段静态代码；

进程：具有独立功能的程序在某个数据集合的一次执行过程；

线程：程序内部的一条执行路径；

多线程的优点：开销小，速度快；

多进程的优点：稳定性高。

二、线程的创建和使用

1.线程创建的两种方式：

（1）继承Thread类：

步骤：

定义子类继承Thread类

重写Thread类的run()方法

创建Thread子类的对象，即创建了线程的对象

调用线程对象的start方法：启动线程，调用run()方法

注意：

自己手动调用的run()方法只是普通方法，并不会启动线程

run()方法调用由CPU决定

启动多线程必须调用start()方法

start()方法只能调用一次，否则会报错

（2）实现Runnable()接口：

步骤：

定义子类实现Runnable()接口

子类重写Runnable()接口中的run方法

定义子类对象

使用Thread类的含参构造器，将子类对象作为参数

调用Thread类的start()方法：开启线程，调用run()方法

区别

 继承 Thread ：线程代码存放 Thread 子类 run 方法中。

 实现 Runnable ：线程代码存在接口的子类的 run 方法。

实现方式的好处

 避免了单继承的局限性

 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线

程来处理同一份资源。

练习：创建两个分线程，让其中一个线程输出1-100之间的偶数，另一个线程输出1-100之间的奇数。

class MyThread1 extends Thread {
   public void run(){
       for (int i = 0; i <100 ; i++) {
           if(i%2==0){
               System.out.println(currentThread().getName()+":"+i);
           }
 
           }
   }
}
class MyThread2 extends Thread {
    public void run(){
        for (int i = 0; i <100 ; i++) {
            if(i%2==1){
                System.out.println(currentThread().getName()+":"+i);
            }
 
        }
 
    }
 
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.start();
        t2.start();
    }
}

Thread类的常用方法：

 void start(): 启动线程，并执行对象的 run() 方法

 run(): 线程在被调度时执行的操作

 String getName(): 返回线程的名称

 void setName(String name) : 设置该线程名称

 static Thread currentThread(): 返回当前线程。在 Thread 子类中就

是 this ，通常用于主线程和 Runnable 实现类

 static void yield() ：线程让步

 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

 若队列中没有同优先级的线程，忽略此方法

 join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将

被阻塞，直到 join() 方法加入的 join 线程执行完为止

 低优先级的线程也可以获得执行

 static void sleep(long millis) ： ( 指定时间 : 毫秒 )

 令当前活动线程在指定时间段内放弃对 CPU 控制 , 使其他线程有机会被执行 , 时间到后

重排队。

 抛出 InterruptedException 异常

 stop(): 强制线程生命期结束，不推荐使用

 boolean isAlive() ：返回 boolean ，判断线程是否还活着

2.线程的调度

调度策略：时间片轮转法、优先级抢占

Java 的调度方法

 同优先级线程组成先进先出队列（先到先服务），使用时间片策略

 对高优先级，使用优先调度的抢占式策略

线程的优先级等级

 MAX_PRIORITY ： 10

 MIN _PRIORITY ： 1

 NORM_PRIORITY ： 5

 涉及的方法

 getPriority() ：返回线程优先值

 setPriority(int newPriority) ：改变线程的优先级

 说明

 线程创建时继承父线程的优先级

 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

三、线程的生命周期

线程的一个完整生命周期应该经历五个状态：

 新建： 当一个 Thread 类或其子类的对象被声明并创建时，新生的线程对象处于新建

状态

 就绪：处于新建状态的线程被 start() 后，将进入线程队列等待 CPU 时间片，此时它已

具备了运行的条件，只是没分配到 CPU 资源

 运行：当就绪的线程被调度并获得 CPU 资源时 , 便进入运行状态， run() 方法定义了线

程的操作和功能

 阻塞： 在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中

止自己的执行，进入阻塞状态

 死亡： 线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

四、线程的同步

1. 多线程出现了安全问题

2. 问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有

执行完，另一个线程参与进来执行。导致共享数据的错误。

3. 解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以

参与执行。

Java 对于多线程的安全问题提供了专业的解决方式： 同步机制

1.同步代码块：

synchronized(对象)
{
//需要被同步的代码
}

2.同步方法： synchronized 还可以放在方法声明中，表示整个方法为 同步方法

public synchronized void show(){
//方法体
}

同步锁机制：

在《 Thinking in Java 》中，是这么说的：对于并发工作，你需要某种方式来防

止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法

就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须

锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁

之时，另一个任务就可以锁定并使用它了。

synchronized 的锁是什么？

 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。

 同步方法的锁：静态方法（类名 .class ）、非静态方法（ this ）

 同步代码块：自己指定，很多时候也是指定为 this 或类名 .class

注意：

 必须确保使用同一个资源的 多个线程共用一把锁 ，这个非常重要，否则就

无法保证共享资源的安全

 一个线程类中的所有静态方法共用同一把锁（类名 .class ），所有非静态方

法共用同一把锁（ this ），同步代码块（指定需谨慎）

线程的死锁问题

 死锁 :不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃

自己需要的同步资源，就形成了线程的死锁

 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于

阻塞状态，无法继续

 解决方法

 专门的算法、原则

 尽量减少同步资源的定义

 尽量避免嵌套同步

五、线程的通信

wait() 与 notify() 和 notifyAll()

 wait() ：令当前线程挂起并放弃 CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当 h2

前线程排队等候其他线程调用 notify() 或 notifyAll() 方法唤醒，唤醒后等待重新获得对监视器的所有

权后才能继续执行。

 notify() ：唤醒正在排队等待同步资源的线程中优先级最高者结束等待

 notifyAll () ：唤醒正在排队等待资源的所有线程结束等待 .

 这三个方法只有在 synchronized 方法或 synchronized 代码块中才能使用，否则会报

java.lang.IllegalMonitorStateException 异常。

 因为这三个方法必须有锁对象调用，而任意对象都可以作为 synchronized 的同步锁，

因此这三个方法只能在 Object 类中声明

六、练习题：

1.有四个窗口卖100张票：

public class Windows implements Runnable{
    private int ticket=100;
    //同步代码快
//    Object obj=new Object();
//    @Override
//    public void run() {
//        while(true){
//            synchronized(obj){
//                try{
//                    Thread.sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }if(ticket>0){
//                        System.out.println(Thread.currentThread().getName() + "卖票" + ticket--);
//                    }else{
//                        break;
//                    }
//                }
//            }
//        }
    private  synchronized void sellTicket(){
      if(ticket>0){
        try{
              Thread.sleep(10);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
            System.out.println(Thread.currentThread().getName() + "卖票" + ticket--);
        }
    }
    @Override
    public void run() {
        while (true) {
            sellTicket();
            if(ticket<=0){
                break;
            }
        }
 
    }
    public static void main(String[] args) {
    Windows window=new Windows();
    new Thread(window,"窗口一：").start();
    new Thread(window,"窗口二：").start();
    new Thread(window,"窗口三：").start();
    new Thread(window,"窗口四：").start();
    }
}

2.生产者—消费者问题

生产者 (Productor) 将产品交给店员 (Clerk) ，而消费者 (Customer) 从店员处

取走产品，店员一次只能持有固定数量的产品 ( 比如 :20 ），如果生产者试图

生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通

知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如

果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题：

 生产者比消费者快时，消费者会漏掉一些数据没有取到。

 消费者比生产者快时，消费者会取相同的数据。

package xiancheng.java;
 
class Clerk {
    private int product = 0;
 
    public synchronized void addProduct() {
        if (product >=20) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            product++;
            System.out.println("生产者生产了第" + product + "个产品！");
            notifyAll();
        }
    }
    public synchronized void takeProduct(){
        if(product<=0){
            try{
            wait();
        } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println("消费者拿走了第" + product + "个产品");
            product--;
            notifyAll();
        }
 
}
}
class Producer implements Runnable {
    private Clerk clerk;
 
    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }
 
    @Override
    public void run() {
        System.out.println("生产者开始生产产品！");
        while(true){
        try {
            Thread.sleep((int) Math.random() * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        clerk.addProduct();
    }}
}
class Consumer implements Runnable{
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        while (true) {
            System.out.println("消费者开始消费产品！");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.takeProduct();
        }
    }
}
public class Producer_Consumer {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Producer producer=new Producer(clerk);
        Consumer consumer=new Consumer(clerk);
       Thread thread1= new Thread(producer);
        Thread thread2= new Thread(consumer);
        thread1.start();
        thread2.start();
    }
 
}

Java多线程