java多线程（详）

/**
   目标：多线程的创建方式一：继承Thread类实现。
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        // 3、new一个新线程对象
        Thread t = new MyThread();
        // 4、调用start方法启动线程（执行的还是run方法）
        //run方法就是一个普通的方法，没有真正启动一个线程，就会把run方法执行完毕，才向下执行，
        //就是会先执行run方法 只有当run执行完毕才会执行其他线程
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }

    }
}

/**
   1、定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /**
       2、重写run方法，里面是定义线程以后要干啥
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

小问题：
为什么不直接调用了run方法，而是调用start启动线程。

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。只有调用start方法才是启动一个新的线程执行。

方式二：实现Runnable接口

定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理。
调用线程对象的start()方法启动线程

构造器	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )	封装Runnable对象成为线程对象，并指定线程名称

优缺点：

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

/**
   目标：学会线程的创建方式二，理解它的优缺点。
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        // 3、创建一个任务对象
        Runnable target = new MyRunnable();
        // 4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        // Thread t = new Thread(target, "1号");
        // 5、启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}

/**
   1、定义一个线程任务类 实现Runnable接口
 */
class MyRunnable  implements Runnable {
    /**
       2、重写run方法，定义线程的执行任务的
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

方式三：JDK 5.0新增：实现Callable接口

1、前2种线程创建方式都存在一个问题：

他们重写的run方法均不能直接返回结果。不适合需要返回线程执行结果的业务场景。

2、怎么解决这个问题呢？

JDK 5.0提供了Callable和FutureTask来实现。这种方式的优点是：可以得到线程执行的结果。

3.多线程的实现方案三：利用Callable、FutureTask接口实现。

(1)、得到任务对象

定义类实现Callable接口，重写call方法，封装要做的事情。

用FutureTask把Callable对象封装成线程任务对象。

(2)、把线程任务对象交给Thread处理。

(3)、调用Thread的start方法启动线程，执行任务

(4)、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

优缺点：
优点：

线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

可以在线程执行完毕后去获取线程执行的结果。

缺点：

编码复杂一点。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
   目标：学会线程的创建方式三：实现Callable接口，结合FutureTask完成。
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        // 3、创建Callable任务对象
        Callable<String> call = new MyCallable(100);
        // 4、把Callable任务对象 交给 FutureTask 对象
        //  FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口），可以交给Thread了
        //  FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        // 5、交给线程处理
        Thread t1 = new Thread(f1);
        // 6、启动线程
        t1.start();


        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            // 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
            String rs1 = f1.get();
            System.out.println("第一个结果：" + rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
            String rs2 = f2.get();
            System.out.println("第二个结果：" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
    1、定义一个任务类 实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型
 */
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    /**
       2、重写call方法（任务方法）
     */
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return "子线程执行的结果是：" + sum;
    }
}

三种方式的比较

方式	优点	缺点
继承Thread类	编程比较简单，可以直接使用Thread类中的方法	扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口	扩展性强，实现该接口的同时还可以继承其他的类。	编程相对复杂，不能返回线程执行的结果
实现Callable接口	扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果	编程相对复杂

三.线程Thread的常用方法

1. 当有很多线程在执行的时候，我们怎么去区分这些线程呢？

此时需要使用Thread的常用方法：getName()、setName()、currentThread()等。

Thread常用方法、构造器

方法名称	说明
String getName()	获取当前线程的名称，默认线程名称是Thread-索引
void setName(String name)	设置线程名称
public static Thread currentThread()：	返回对当前正在执行的线程对象的引用
public static void sleep(long time)	让线程休眠指定的时间，单位为毫秒。
public void run()	线程任务方法
public void start()	线程启动方法

构造器	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	把Runnable对象交给线程对象
public Thread(Runnable target ，String name )	把Runnable对象交给线程对象，并指定线程名称


public class MyThread extends Thread{
    public MyThread(){}
    public MyThread(String name){
        super(name);
    }

    public void run(){
        for(int i=0;i<50;i++){
            System.out.println(getName()+"追逐王二的速度"+i+"km/h");
        }
    }
}







public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t=new MyThread("张三");
        Thread t1=new MyThread("李四");
        t.start();
        t1.start();
    }

}

四.线程调度

线程有两种调度模型
        ●分时调度模型: 所有线程轮流使用CPU的使用权，平均分配每个钱程占用CPU的时间片
        ●抢占式调度模型: 抢占式调度模型:优先让优先级高的线程使用cpu，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些
        Java使用的是抢占式调度模型
假如计算机只有一个CPU, 那么CPU在某一个时刻只能执行一条指令, 线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性,因为谁抢到CPU的使用权是不一定的

Thread类中设置和获取线程优先级的方法
●public final int getPriority0:返回此线程的优先级
public final void setPriority(int newPriority):更改此线程的优先级

五.线程控制

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

static void sleep(long millis) ：可以让线程1秒内同时开始，然后停止。只有前后的争夺不会连续；

 public void run() {
        for (int i=0;i<50;i++){
            System.out.println(getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

void join（）：“李渊”死了之后李世民和李建成才能开始夺位，所以join（）是等设置的线程死亡其他线程才能工作。

public static void main(String[] args) {
        Thread t=new zh01("李渊");
        Thread t1=new zh01("李世民");
        Thread t2=new zh01("李建成");
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.start();
        t2.start();
    }

void setDaemon(booleanon) ：设置一个主线程，其他守护线程等主线程死亡后，也慢慢停止运行

public class Zh04 {
        public static void main(String[] args) {
            zh01  td1 = new zh01  () ;
            zh01   td2 = new zh01  ( ) ;
            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);
            }
        }

    }

六.线程的生命周期：

NEW(新建)	线程刚被创建，但是并未启动。
Runnable(可运行)	线程已经调用了start()等待CPU调度
Blocked(锁阻塞)	线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态；。
Waiting(无限等待)	一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

七.线程同步

需求：某电影院正在上演一部大片，现有100张票在三个窗口销售，用线程模拟三个窗口的售票速度和票数情况，所以我们用sleep（）方法模拟售票等待时机

package 多线程;

public class Buypiao extends Thread{
    public Buypiao(){

    }
    public Buypiao(String name){
        super(name);
    }
    private int piao=100;
    @Override
    public void run() {
     while (true){
          try {
              Thread.sleep(100);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          if(piao>0){
              System.out.println(Thread.currentThread().getName()+"销售还有"+piao+"张");
              piao--;
          }
      }

    }




package 多线程;

public class Buypiaodomn {
    public static void main(String[] args) {
        Buypiao buy=new Buypiao("窗口1");
        Buypiao buy1=new Buypiao("窗口2");
        Buypiao buy2=new Buypiao("窗口3");
        buy.start();
        buy1.start();
        buy2.start();
    }
}

我们发现在运行的时候出现了票数重复：假设t1线程先抢到cpu的执行权，但是需要休息，这个时候t2抢到cpu的执行权，故此t2也开始执行，t3也是如此；最后才能减少票数

问题分析：

为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准
●是否是多线程环境
●
是否有共享数据
●是否有多条语句操作共享数据
如何解决多线程安全问题呢?
●基本思想: 让程序没有安全问题的环境
怎么实现呢? .
●把多条语句操作共享数据的代码给锁起来, 让任意时刻只能有一个线程执行即可
●Java提供了同步代码块的方式来解决

1.同步代码块：

格式：

synchronized (任意对象：相当于一把锁) {

多条语句操作共享语句的代码

}

作用：把出现线程安全问题的核心代码给上锁。

原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

锁对象的规范要求

规范上：建议使用共享资源作为锁对象。

对于实例方法建议使用this作为锁对象。

对于静态方法建议使用字节码（类名.class）对象作为锁对象。

同步代码块是如何实现线程安全：

对出现问题的核心代码使用synchronized进行加锁

每次只能一个线程占锁进入访问

 public void run() {
      while (true) {
          synchronized (obj) {
              if (piao > 0) {
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println(Thread.currentThread().getName() + "销售还有" + piao + "张");
                  piao--;
              }
             }
        }
      }

问题解决思路：

假设 t1抢到了cpu的执行权，然后t1开始运行，t1休息的时候t2抢到cpu的执行权，因为代码上锁所以只能等待，等t1休息好，这段代码的锁就被释放了，运行完t2才开始执行，这个时候代码也会一步步递减

同步的好处和弊端
●好处:解决了多线程的数据安全问题
●弊端:当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率

2.同步方法：

就是把synchronized关键词加到方法上

格式：

修饰符synchronized返回值类型方法名（方法参数）{ }

同步方法的锁对象：

this

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

格式：

修饰符static synchronized返回值类型方法名（方法参数）{ }

同步方法的锁对象：

类名.class

作用：把出现线程安全问题的核心方法给上锁。

原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

底层原理：

同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

如果方法是实例方法：同步方法默认用this作为的锁对象。

但是代码要高度面向对象！如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

3.lock锁

为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。

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

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象

方法名称	说明
public ReentrantLock()	获得Lock锁的实现类对象
方法名称	说明
void lock()	获得锁
void unlock()	释放锁

 while (true) {
        lock.lock();
              if (piao > 0) {
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println(Thread.currentThread().getName() + "销售还有" + piao + "张");
                  piao--;
              }
              lock.unlock();
        }
      }

八.线程池

1.概念

线程池就是一个可以复用线程的技术。

2.不使用线程池的问题

如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

3.工作原理

4.如何得到线程池对象

方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

ExecutorService–>ThreadPoolExecutor

方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

5.ThreadPoolExecutor构造器的参数说明

参数一：指定线程池的线程数量（核心线程）： corePoolSize—>不能小于0

参数二：指定线程池可支持的最大线程数： maximumPoolSize—>最大数量 >= 核心线程数量

参数三：指定临时线程的最大存活时间： keepAliveTime—>不能小于0

参数四：指定存活时间的单位(秒、分、时、天)： unit—>时间单位

参数五：指定任务队列： workQueue—>不能为null

参数六：指定用哪个线程工厂创建线程： threadFactory—>不能为null

参数七：指定线程忙，任务满的时候，新任务来了怎么办： handler —>不能为null

6.线程池常见面试题:

临时线程什么时候创建啊？

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

什么时候会开始拒绝任务？

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

作者有话说

咋就是说本来只想写点的结果越写发现线程越神秘，要不是实力受限咋能写本书出来，线程真的有点强了，还有一些写了怕误导大家就不进行反面教材了！！！谢谢大家支持！！！

今天的文章java多线程（详）分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/24098.html