多线程

程序:一段静态的代码

进程:正在运行的一个程序,系统在运行时为每一个进程分配不同的内存区域。

线程:进程的进一步细化,与进程共享一个内存区域,但是有独立的运行栈和程序计数器。

单核CPU:假的多线程,一个线程执行一次,时间间隔较短,类似多车道,一个收费站。

多核CPU:更好的发挥多线程的效率。

一个java程序至少有三个线程:main()、gc()垃圾回收、异常处理线程。

并行:多个CPU执行多个任务

并发:一个CPU执行多个任务,如:秒杀,多人做同一件事

多线程的优点:

  1. 提高程序的相应,对于图形化界面,提高用户的体验
  2. 提高cpu的利用率。
  3. 将程序拆分成多个任务,方便代码的独立运行。

1、线程的创建和使用

线程的创建

方式一:继承于Thread

  1. 创建一个继承Thread类的子类
  2. 重写run()方法
  3. 创建Thread类的子类
  4. 通过子类对象调用start()方法

start()方法:①启动该线程 ②调用run()方法

注意

  1. 直接调用run()方法并不会开启新的线程,是主线程正常运行run()方法。
  2. 不可以两次运行(同一对象调用2次start方法)相同的线程,必须重新new 线程对象。

方式二:实现Runnable接口

  1. 创建一个实现Runnable接口的类。
  2. 实现类实现run()方法。
  3. 创建实现类对象
  4. new Thread(实现类对象)
  5. 通过Thread类的对象调用 start()

Thread中的常用方法:

  1. start(),启用线程,调用run()
  2. run(),将需要多线程需要执行的方法写里面
  3. currentThread(),静态方法,返回当前执行代码的线程
  4. getName(),获取线程名
  5. setName(),设置线程名 / new Thread("线程名");
  6. yield(),释放当前cpu执行权
  7. join():在线程A中调用线程B的join方法,此时A就进入阻塞状态,直到B执行完,A才继续执行。
  8. sleep(long millitime):让当前线程睡眠一定的毫秒时间
  9. isAlive():判断当前线程是否存活

线程的调度

  • 线程的优先级:

MAX_PRIORITY :10

NORM_PRIORITY :5 默认优先级

MIN_PRIORITY :1

注意:高优先级的线程要抢占低优先级的线程cpu执行权,但是只是从概率上讲,并不是一定。

  • 获取或设置当前线程的优先级

getPriority(): 获取

setPriority();设置

比较两种创建线程的方式:

开发中,优先选择实现Runnable接口的方式。

原因:

  1. 实现的方式没有类单继承的局限性
  2. 实现的方式更适合处理多个线程共有数据的情况

2、线程的生命周期

  1. 新建:调用start()
  2. 就绪:等待取得cpu资源
  3. 运行:
  4. 阻塞:①sleep() ②join() ③等待同步锁 ④wait()
  5. 死亡:①执行完 ②stop() ③error/exception且没有处理。
    多线程

3、线程的同步

在java中,我们通过同步机制,来解决线程的安全问题。

同步的方式:

好处:解决了线程的安全问题

局限性:操作同步代码时,只有一个线程能操作,效率比较低。

方式一:同步代码块

    synchronized(同步监视器){
    //需要被同步的代码
    }

说明:

  1. 需要操作共享数据的,就视为同步的代码。
  2. 同步监视器(锁),任何一个类的对象都可以充当锁。要求:多个线程共用一把锁
  3. 在实现Runnable接口的方式中,可以使用this充当锁
  4. 在继承Thread的方式中,慎用this充当锁。可考虑当前对象

方式二:同步方法

操作共享数据的代码完整声明在一个方法中,可使用同步方法的方式。

实现Runnable接口的方式

public synchronize void  a(){
}

继承Thread的方式

public static synchronize void  a(){
}

注意:

  1. 在该方式中,没有显式的锁。
  2. 非静态的同步方法,默认锁是this。
  3. 静态的同步方法,琐是当前类本身。

改写单例模式中的懒汉式为线程安全:

class Bank{
    private Bank(){}
    private static Bank instance = null;

    private static Bank getInstance(){
        
        if (instance == null){
            synchronized (Bank.class){
                if (instance == null){
                    instance = new Bank();
                }
            } 
        }
        return instance;
    }
}

4、线程的死锁

理解:不同线程占用对方需要的资源不释放,处于僵持的状态,都在互相等待。

说明:出现死锁后程序并不会出现异常,只是所有线程都处于阻塞的状态。

解决方法:

  1. 专门的算法、原则
  2. 尽量减少同步资源的定义
  3. 避免嵌套同步

5、线程的同步--锁

Lock锁-----jdk5.0新增

  1. 实例化 ReentrantLock()对象

    ReentrantLock lock = new ReentrantLock();
    
  2. 调用锁定方法lock.lock();

  3. 解锁lock.unlock();

synchronize 与 Lock 异同? (面试题)

  • 相同:都可以解决线程安全问题

  • 不同:synchronize 机制在执行完相应的同步代码后,自动释放锁。

    ​ Lock需要手动上锁(lock())和解锁(unLock());

使用顺序(建议/非必须)

Lock-->同步代码块-->同步方法

如何解决线程安全问题?有几种方式?(面试题)

三种:同步块,同步方法,锁Lock

6、线程的通信

线程通信的三个方法:

  1. wait() : 一旦执行此方法,当前线程就进入阻塞状态,并释放锁
  2. notify() : 执行此方法,唤醒被wait()的线程,如果有多个,就唤醒优先级高的
  3. notifyAll() : 执行此方法,唤醒全部wait()的线程

注意:

  1. 三个方法只能使用在同步代码块或同步方法中。
  2. 三个方法的调用者,必须是同步代码块或同步方法中的监视器(锁),否者会出现异常。
  3. 三个方法定义在Object中,不是Tread中。

实例:两个线程交替打印1-100

public class Test {

    public static void main(String[] args) {
        Number number = new Number();

        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}


class Number implements Runnable{
    int number = 1 ;

    @Override
    public void run() {
        while (true){
            synchronized (this) {
                notify();
                if (number<=100){
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                }
                else{
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

sleep()和 wait()方法的异同? (面试题)

  • 相同:都可以使线程阻塞
  • 不同:
  1. 两者声明的位置不同,sleep()声明在Thread类,而wait()声明在Object类。
  2. sleep可以在任何位置使用,而wait()只能在同步代码块和同步方法中使用。
  3. 当两者都使用在同步代码块和同步方法中时,sleep()不会释放锁,wait()会释放锁

例题生产者消费者

产品小于0个不能购买,大于0个可购买。

产品大于20不能再生产,不足20继续生产。

销售类

class Clerk{

    private int num = 0;

    public synchronized void produceProduct() {
        if(num<20){
            num++;
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":开始生产第"+num+"个产品");
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void customerProduct() {
        if(num>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":开始消费第"+num+"个产品");
            num--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

生产者

class Producter extends Thread{

    private Clerk clerk;

    public Producter(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        while (true){
            clerk.produceProduct();
        }
    }
}

消费者

class Customer extends Thread{

    private Clerk clerk;

    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        while (true){
            clerk.customerProduct();
        }
    }
}

测试

public class ProductTest {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producter p1 = new Producter(clerk);
        Customer c1 = new Customer(clerk);
        Customer c2 = new Customer(clerk);

        p1.setName("生产者1");
        c1.setName("消费者1");
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();
    }
}

7、新增线程的创建方式

方式一:实现Callable接口

JDK5.0 新增

与实现runnable接口相比更加强大:

  1. call方法中可以有返回值。
  2. call()可以抛出异常,被外面的操作捕获。
  3. Callable支持泛型。

步骤:

  1. 创建Callable的实现类
  2. 将要执行的操作写在Callable实现类的call方法中。
  3. 创建callable的实现类对象
  4. 创建FutureTask 对象 ,callable的实现类对象作为参数。
  5. new Thread(FutureTask 对象).start()开启线程;
  6. 可使用FutureTask 对象的get()方法,获取call()方法的返回值。

方式二:使用线程池

思路:提前建立好多个线程,放入线程池,随用随取。

好处:①提高响应速度②降低资源消耗

③便于线程管理:

  1. 线程池大小
  2. 线程数
  3. 没有任务的持续时间

步骤:

 //1.提供指定数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //2.执行指定线程操作,需要提供实现runnable/callable类的对象
        executorService.execute(new Number());
		//executorService.submit(callable callable);
        //3.关闭线程池
        executorService.shutdown();

创建多线程有几种方式?(面试题)

4种:继承Tread

实现Runnable

实现Callable

线程池

上一篇:Oracle常用函数--lag()函数和lead()函数


下一篇:简易封装 XHR:支持 GET/POST/PUT/DELETE/JSONP/FormData