Java多线程入门

---

1、实现多线程

1.1、进程

进程： 是正在运行的程序。

• 是系统进行资源分配和调用的独立单位。
• 每一个进程都有它自己的内存空间和系统资源。

1.2、线程

线程： 是进程中的单个顺序控制流，是一条执行路径。

• 单线程： 一个进程如果只有一条执行路径，则称为单线程程序。
• 多线程： 一个进程如果有多条执行路径，则称为多线程程序。
  举例：
  单线程：记事本
  多线程：扫雷

1.3、多线程的实现方式

方式一：

• 定义一个类MyThread继承Thread类。
• 在MyThread类中重写run()方法。
• 创建MyThread类的对象。
• 启动线程。

//MyThread.java
package com.test;

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(i);
        }
    }
}

//Demo.java
package com.test;

public class Demo {
    public static void main(String[] args) {
        MyThread mt1=new MyThread();
        MyThread mt2=new MyThread();

//        mt1.run();
//        mt2.run();

        mt1.start();
        mt2.start();
    }


}

为什么要重写run()方法？

• 因为run()是用来封装被线程执行的代码。

run()方法和start()方法的区别?

• run()：封装线程执行的代码，直接调用相当于普通方法的调用。
• start()：启动线程，然后由JVM调用此线程的run()方法。

1.4、设置和获取线程名称

Thread类中设置和获取线程名称的方法：

• void setName(String name)：将此线程的名称更改为等于参数name
• String getName()：返回此线程的名称。

方式一：默认线程名称

package com.test;

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(this.getName()+":"+i);//getName获取线程名称
        }
    }
}

package com.test;

public class Demo {
    public static void main(String[] args) {
        MyThread mt1=new MyThread();
        MyThread mt2=new MyThread();

        mt1.start();
        mt2.start();
    }

方式二：自定义线程名称

package com.test;

public class Demo {
    public static void main(String[] args) {
        MyThread mt1=new MyThread();
        MyThread mt2=new MyThread();
        
        mt1.setName("高铁");
        mt2.setName("飞机");
        mt1.start();
        mt2.start();
    }

}

方式三：创建对象时自定义线程名称

package com.test;

public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(this.getName()+":"+i);
        }
    }
}

package com.test;

public class Demo {
    public static void main(String[] args) {
        MyThread mt1=new MyThread("高铁");
        MyThread mt2=new MyThread("飞机");

        mt1.start();
        mt2.start();
    }

}

获取当前线程的名称：

public class Demo {
    public static void main(String[] args) {
        String name = Thread.currentThread().getName();
        System.out.println(name);
    }

}

1.5、线程调度

线程有两种调度模型：

• 分时调试模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片。
• 抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取CPU时间片相对多一些。
• JAVA使用的是抢占式调度模型。

Thread类中设置和获取线程优先级的主法：

• public final int getPriority()：返回此线程的优先级。
• public final void setPriority(int newPriority)：更改此线程的优先线。
• 线程默认优先级是5；
• 线程优先级的范围是：1-10；
• 线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行时才能看到效果。

package com.test1;

public class ThreadPriority extends Thread{

        @Override
        public void run() {
            for(int i=0;i<100;i++){
                System.out.println(this.getName()+":"+i);
            }
        }

}

package com.test1;

public class Demo {
    public static void main(String[] args) {
        ThreadPriority tp1=new ThreadPriority();
        ThreadPriority tp2=new ThreadPriority();
        ThreadPriority tp3=new ThreadPriority();
        
        tp1.setName("飞机");
        tp2.setName("高铁");
        tp3.setName("汽车");
        //获取线程优先级
        System.out.println(tp1.getPriority());//5
        System.out.println(tp2.getPriority());//5
        System.out.println(tp3.getPriority());//5
        
        //线程优线级别范围
        //tp1.setPriority(100);//IllegalArgumentException
        System.out.println(Thread.MAX_PRIORITY);//最高优先级别10
        System.out.println(Thread.MIN_PRIORITY);//最低优先级别1
        System.out.println(Thread.NORM_PRIORITY);//默认优先级别5
        //更改线程优先级别        
        tp1.setPriority(10);
        tp2.setPriority(5);
        tp2.setPriority(1);
        
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

1.6、线程控制

方法名	说明
static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数
void join()	等待这个线程死亡
void setDaemon(boolean on)	true:将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

sleep示例：

package com.test2;

public class ThreadSleep extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName()+","+i);
        }
    }
}

package com.test2;

public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1=new ThreadSleep();
        ThreadSleep ts2=new ThreadSleep();
        ThreadSleep ts3=new ThreadSleep();

        ts1.setName("孙悟空");
        ts2.setName("猪八戒");
        ts3.setName("沙悟净");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}

join示例：

package com.test2;

public class ThreadJoin extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+","+i);
        }
    }
}

package com.test2;

public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1=new ThreadJoin();
        ThreadJoin tj2=new ThreadJoin();
        ThreadJoin tj3=new ThreadJoin();

        tj1.setName("康熙");
        tj2.setName("胤禔");
        tj3.setName("胤礽");
        
        //tj1执行完以后，tj2、tj3才能执行
        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}

setDaemon示例：

package com.test2;

public class ThreadDaemon extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+","+i);
        }
    }
}

package com.test2;

public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1=new ThreadDaemon();
        ThreadDaemon td2=new ThreadDaemon();

        td1.setName("关羽");
        td2.setName("张飞");

        //设置主张程为刘备
        Thread.currentThread().setName("刘备");

        //设置守护进程，主线程运行结束，守护线程也会很快结束
        td1.setDaemon(true);
        td2.setDaemon(true);

        td1.start();
        td2.start();

        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+","+i);
        }

    }
}

1.7、线程的生命周期

1.8、Runnable接口方式实现多线程

实现Runnable接口：

• 定义一个类MyRunnable实现Runnable接口。
• 在MyRunnable类中重写run()方法。
• 创建MyRunnable类的对象。
• 创建Thread类的对象，把MyRunnable对象作为构造方法的参数。
• 启动线程。

Runnable接口方式实现多线程示例：

package com.test3;

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

package com.test3;

public class Demo {
    public static void main(String[] args) {
        MyRunnable mr=new MyRunnable();

        Thread th1=new Thread(mr);
        Thread th2=new Thread(mr,"飞机");
        th1.setName("高铁");

        th1.start();
        th2.start();
    }
}

多线程的实现方式有两种：

• 继承Thread类
• 实现Runnable接口
  相比继承Thread类，实现Runnable接口的好处：
• 避免Java单继承的局限性。
• 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想。

2、线程同步

2.1、三个窗口同时卖火车票

package com.test4;

public class SellTicket implements Runnable{
    private int tickets=100;
    @Override
    public void run() {
        while(true){
            if(tickets>0){
                //延迟100毫秒
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                tickets--;
            }
        }
    }
}

package com.test4;

public class Demo {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();

        Thread th1=new Thread(st,"窗口1");
        Thread th2=new Thread(st,"窗口2");
        Thread th3=new Thread(st,"窗口3");

        th1.start();
        th2.start();
        th3.start();
    }
}

输出结果：

2.2、多线程程序数据安全问题

卖票案例数据安全问题（判断多线程程序是否有数据安全问题的标准）：

• 是否多线程环境
• 是否有共享数据
• 是否有多条语句操作共享数据
• 上述三个条件同时存在就会存在数据安全问题。

解决办法：

• 将多条语句操作共享数据的代码锁起来，让任意时刻只能有一个线程执行即可。
• Java提供了同步代码块的方式来解决。

2.3、同步代码块

锁多条语句操作共享数据，可以使用同步代码块实现：

• 格式：

  synchronized(任意对象){
  	多条语句操作共享数据的代码
  }
  

• synchronized(任意对象)：就相当于给代码加锁了，任意对象可以看成是一把锁。

package com.test4;

public class SellTicket implements Runnable{
    private int tickets=100;
    private Object obj=new Object();
    @Override
    public void run() {
        //同步代码块

        while(true){
            synchronized (obj){
                if(tickets>0){
                    //延迟100毫秒
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                    tickets--;
                }
            }
        }

    }
}

同步的好处和弊端：

• 好处：解决了线程的数据安全问题。
• 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，会很耗费资源，降低程序的运行效率。

2.4、同步方法

一、同步方法：
就是把synchronized关键字加到方法上：

• 格式：

修饰符synchronized 返回值类型 方法名(方法参数){

}

同步方法的锁对象是什么？

• this

锁对象是obj

package com.test4;

public class SellTicket implements Runnable{
    private int tickets=100;
    private Object obj=new Object();
    private int x=0;
    @Override
    public void run() {
        //同步代码块

        while(true){
            if(x%2==0){
                synchronized (obj){
                    if(tickets>0){
                        //延迟100毫秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;
                    }
                }
            }else{
                synchronized (obj){
                    if(tickets>0){
                        //延迟100毫秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;
                    }
                }
            }

        }

    }

锁对象是obj

package com.test4;

public class SellTicket implements Runnable{
    private int tickets=100;
    private Object obj=new Object();
    private int x=0;
    @Override
    public void run() {
        //同步代码块

        while(true){
            if(x%2==0){
                synchronized (obj){
                    if(tickets>0){
                        //延迟100毫秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;
                    }
                }
            }else{
                sellTicket();
            }

        }

    }

    private void sellTicket() {
        synchronized (obj){
            if(tickets>0){
                //延迟100毫秒
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                tickets--;
            }
        }
    }
}

同步方法锁对象是this

package com.test4;

public class SellTicket implements Runnable{
    private int tickets=100;
//    private Object obj=new Object();
    private int x=0;
    @Override
    public void run() {
        //同步代码块

        while(true){
            if(x%2==0){
                synchronized (this){
                    if(tickets>0){
                        //延迟100毫秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;
                    }
                }
            }else{
                sellTicket();
            }

        }

    }

    //这里的同步对象是this
    private synchronized void sellTicket() {
            if(tickets>0){
                //延迟100毫秒
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                tickets--;
            }
    }
}

二、同步静态方法：
就是把synchronized关键字加到静态方法上：

• 格式：

修饰符 static synchronized 返回值类型 方法名(方法参数){

}

同步静态方法的锁对象是什么？

• 类名.class

同步静态方法的锁对象是类名.class

package com.test4;

public class SellTicket implements Runnable{
//    private int tickets=100;
    private static int tickets=100;
    private int x=0;
    @Override
    public void run() {
        //同步代码块

        while(true){
            if(x%2==0){
                synchronized (SellTicket.class){
                    if(tickets>0){
                        //延迟100毫秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;
                    }
                }
            }else{
                sellTicket();
            }

        }

    }

    
    private static synchronized void sellTicket() {
            if(tickets>0){
                //延迟100毫秒
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                tickets--;
            }
    }
}

2.5、线程安全的类

StringBuffer

• 线程安全，可变的字符序列。
• 从版本JDK5开始，被StringBuilder替代。通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步。

Vector

• 从Java2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。与新的集合实现不同，Vector被同步。如同不需要线程安全的实现，建议使用ArrayList代替Vector。

Hashtable

• 该类实现了一个啥希表，它将键映射到值。任何非null对象都可以用作键或者值。
• 从Java2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。与新的集合实现不同，Hashtable被同步。如果不需要线程安全的实现，建议使用HashMap代替Hashtable

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer();//线程不安全
        StringBuilder sb1=new StringBuilder();//线程安全

        ArrayList<String> array=new ArrayList<String>();//线程不安全
        Vector<String> v=new Vector<String>();//线程安全

        HashMap<String,String> hm=new HashMap<String,String>();//线程不安全
        Hashtable<String,String> ht=new Hashtable<String,String>();//线程安全
        
        //线程安全，一般List、Map等可以使用这种方式实现线程安全
        List<String> list = Collections.synchronizedList(new ArrayList<String>());
        Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>());
    }
}

2.6、Lock锁

• JDK5以后提供了一个新的锁对象Lock。

• Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。

获得锁和释放锁的方法：

• void lock()：获得锁。
• void unlock()：释放锁。

ReentrantLock的构造方法：
Lock是接口不能直接实例化，可采用它的实现类ReentrantLock来实例化

• ReentrantLock()：创建一个ReentrantLock的实例。

示例：

package com.test5;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SellTicket implements Runnable{
    private int tickets=100;
    private Lock lock=new ReentrantLock();

    @Override
    public void run() {
        while(true){

            try{
                lock.lock();
                if(tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+"正在出售第"+tickets+"张票");
                    tickets--;
                }
            }finally {
                    lock.unlock();
            }


        }
    }
}

package com.test5;

public class Demo {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();

        Thread th1=new Thread(st,"窗口1");
        Thread th2=new Thread(st,"窗口2");
        Thread th3=new Thread(st,"窗口3");

        th1.start();
        th2.start();
        th3.start();
    }

}

3、生产者消费者

3.1、生产者消费者概述

生产者消费者模式是一个十分经典的多线程协作模式。
生产者消费者问题，主要包含了两类线程：

• 一类是生产者线程用于生产数据。
• 一类是消费者线程用于消费数据。

为 了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像一个仓库

• 生产者生产数据后放在共享数据区中，并不需要关心消费者的行为。
• 消费者只需要从共享数据中去获取数据，并不需要关心生产者的行为。
  
  为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法，这几个方法在Object类中：

方法名	说明
void wait()	导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法
void notify()	唤醒正在等待对象监视器的单个线程
void notifyAll()	唤醒正在等待对象监视器的所有线程

3.2、生产者消费者案例

生产者消费者案例中包含的类：

• 奶箱类（Box）:定义一个成员变量，表示第X瓶奶，提供存储和获取牛奶的操作。
• 生产者类（Producer）：实现Runnable接口，重写run()方法，调用存储牛奶的操作。
• 消费者类（Customer）：实现Runnable接口，重写run()方法，调用获取牛奶的操作。
• 测试类：有main方法，main方法中步骤如下：
  • 创建奶箱对象，这是共享数据区域
  • 创建生产者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用存储牛奶的操作。
  • 创建消费者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用获取牛奶的操作。
  • 创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递。

package com.test6;

public class Box {
    private int milk;//定义一个成员变量，表示第X瓶奶
    private boolean state=false;//表示奶箱的状态

    //存储牛奶
    public synchronized void put(int milk){
        //如果有牛奶，等待消费
        if(state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //没有牛奶，生产牛奶
        this.milk=milk;
        System.out.println("送奶工将第"+this.milk+"瓶奶放入奶箱");
        state=true;//更改奶箱状态
        notifyAll();//唤醒其它线程
    }

    //获取牛奶
    public synchronized void get(){
        //如果没有牛奶，等待生产
        if(!state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //有牛奶，则获取
        System.out.println("用户拿到第"+this.milk+"瓶奶");
        state=false;//更改奶箱状态
        notifyAll();//唤醒其它线程
    }
}

package com.test6;

public class Producer implements Runnable{
    private Box b;
    public Producer(Box b) {
        this.b=b;
    }

    @Override
    public void run() {
        for(int i=1;i<=5;i++){
            b.put(i);
        }
    }
}

package com.test6;

public class Customer implements Runnable{
    private Box b;
    public Customer(Box b) {
        this.b=b;
    }

    @Override
    public void run() {
        while(true){
            b.get();
        }
    }
}

package com.test6;

public class Demo {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据
        Box b=new Box();

        Producer p=new Producer(b);//创建生产者对象
        Customer c=new Customer(b);//创消费者对象

        //创建两个线程对象
        Thread th1=new Thread(p);
        Thread th2=new Thread(c);

        //启动线程
        th1.start();
        th2.start();
    }
}