Java(九)(多线程,线程安全,实现线程的方法,线程同步,线程池,并发和并行,线程的六种状态)

多线程

线程

实现线程的方法

方法一:继承Thread父类

方法二:实现Runnable接口

方法三:Callable接口和FutureTask类来实现

Thread方法

线程安全

线程同步

同步代码块

同步方法

Lock锁

线程池

线程池对象的创建方式一:

线程池处理Runnable任务

线程池处理Callable任务

并发和并行

并发的含义

并行的理解

线程的六种状态

多线程

线程

线程(Thread是一个程序内部单独一条执行流程),程序中如果只有一条执行流程,那这个程序就是单线程的程序

实现线程的方法

方法一:继承Thread父类

我们先写一个MyThread类,表示我们创建的子线程类

public class MyThread extends Thread{
    @Override
    public void run(){
        for (int i = 0; i <= 5; i++) {
            System.out.println("子线程MyThread输出"+i);
        }
    }
}

我们实现main方法

public class main_Thread {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        for (int i = 0; i <= 5; i++) {
            System.out.println("主线程main输出:"+i);
        }
    }
}

输出结果为

说明我们现在有两个线程,每一个线程都先运行

需要我们注意的是:

第一点: 我们在子类中重写了run方法,但是我们在调用创建的线程对象t的方法是start(),如果是run()方法会变成单线程,会先执行完run方法里的才会执行main函数中的

第二点: 我们的子线程要放到主线程的前面

缺点:一个子类只能继承一个父类,不能再继承其他类,所以继承了Thread之后,不能继承其他类,会导致功能减少

方法二:实现Runnable接口

(1)定义一个线程任务类MyRunnable实现Runnable接口,重写run()方法

public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程1---->"+i);
        }
    }
}

(2)创建MyRunnable任务对象

Runnable r = new MyRunnable();

(3)把MyRunnable任务对象交给Thread处理并且调用对象的start()方法启动线程

new Thread(r).start();

下面是mian方法的完整代码

public class main_Thread {
    public static void main(String[] args) {
        // 创建MyRunnable任务对象
        Runnable r = new MyRunnable();
        new Thread(r).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("mian线程--->"+i);
        }
    }
}

代码优化

不创建子类,用匿名内部类

public class main_Thread {
    public static void main(String[] args) {
        // 创建MyRunnable任务对象

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程--->"+i);
                }
            }
        }).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("mian线程--->"+i);
        }
    }
}

优点: 任务类只能实现接口,可以继续继承其他类,实现其他接口

缺点: 需要多一个Runable对象

方法三:Callable接口和FutureTask类来实现

使用原因:因为我们上面两个方法都是调用start方法,进而让调用run方法的,而run方法是void类型的,不会给我们返回值,这时候就要用到方法三

最大优点:可以返回线程执行完毕后的结果

创建线程的步骤:

1.创建任务对象:

(1)定义一个类实现Callable接口,重写call方法,封装要做的事情,和返回的数据

import java.util.concurrent.Callable;

public class MyCall implements Callable<String> {
    private int n ;

    public MyCall(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        // 描述线程的任务,返回线程执行返回后的结果
        // 需求:求1-n的和返回
        int sum = 0;
        for (int i=1;i<n;i++)
        {
            sum+=i;
        }

        return ""+sum;
    }
}

(2)把Callable类型的对象封装成FutureTask(线程任务对象)

//创建一个Callable对象
        Callable<String> call = new MyCall(100);

2.把线程任务对象交给Thread对象

// 把Callable的对象封装成一个FutureTask对象
        // 未来任务对象的作用?
        // 1.是一个任务对象,实现Runnable对象
        // 2.可以在线程执行完毕后,
        // 用未来线程对象调用get方法获取线程执行完毕后值
        FutureTask<String> f1 = new FutureTask<>(call);

3.调用Thread对象的start方法启动线程

// 把任务对象交给一个Thread对象
        new Thread(f1).start();

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

// 获取线程执行完毕后返回的结果
        // 注意: 如果执行到这,假如说线程还没有执行完毕
        // 这里的代码会暂停,等待上面线程执行完毕后才会获取结果
        String s = f1.get();
        System.out.println(s);

mian主线程中的完整代码


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

public class main_Thread {
    public static void main(String[] args) throws Exception {
        //创建一个Callable对象
        Callable<String> call = new MyCall(100);
        // 把Callable的对象封装成一个FutureTask对象
        // 未来任务对象的作用?
        // 1.是一个任务对象,实现Runnable对象
        // 2.可以在线程执行完毕后,
        // 用未来线程对象调用get方法获取线程执行完毕后值
        FutureTask<String> f1 = new FutureTask<>(call);
        // 把任务对象交给一个Thread对象
        new Thread(f1).start();

        // 获取线程执行完毕后返回的结果
        // 注意: 如果执行到这,假如说线程还没有执行完毕
        // 这里的代码会暂停,等待上面线程执行完毕后才会获取结果
        String s = f1.get();
        System.out.println(s);

    }
}

Thread方法

public class main_Thread {
    public static void main(String[] args) throws Exception {
        Thread t1 = new MyThread();
        t1.setName("1号线程");
        t1.start();
        System.out.println(t1.getName()); // 输出线程1的名字

        Thread t2 = new MyThread();
        t2.setName("2号线程");
        t2.start();
        System.out.println(t2.getName()); // 输出线程2的名字

        // 主线程对象的名字
        Thread m = Thread.currentThread(); // 拿到当前执行线程名字
        m.setName("nb线程");
        System.out.println(m.getName()); // main

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

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i <=5 ; i++) {
            if(i== 3)
            {
                // 让当前的线程停止5秒
                Thread.sleep(5000);
            }
        }
        // join方法让调用方法的线程先执行完
        Thread t1 = new Thread();
        t1.start();
        t1.join();

    }
}

线程安全

线程安全问题的原因: 多个线程,同时访问同一个共享资源,且存在修改资源

我们来模拟线程安全,假如说现在取钱,小明和小红在同一个账户下取钱,现在账户有10万元,小明在他的手机上取10万元,小红在她的手机取10万元,想有没有一种可能小明的手机判断有钱但是还没有取钱的同时,小红的手机也判断有钱,也要完成取钱操作,这样的话小明取出来了10万元,小红手机也取出了10万元,而账户中只有10万元,这就是线程安全

我们用代码模拟一下这个情况

我们先创建账户类,用来创建账户对象

package surf_Thread;

public class Account {
    private String Id;
    private int money;

    public Account() {
    }

    public Account(String id, int money) {
        Id = id;
        this.money = money;
    }

    public String getId() {
        return Id;
    }

    public void setId(String id) {
        Id = id;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void drawMoney(int i) {
        // 先搞清楚谁来取钱?
        String name = Thread.currentThread().getName();
        // 判断余额是否足够
        if(this.money>=i)
        {
            System.out.println(name+"来取钱"+money+"成功");
            this.money-=i;
            System.out.println(name+"来取钱后,余额剩余: "+money);
        }
        else{
            System.out.println(name + "来取钱,余额不足");
        }
    }
}

我们在上面创建了一个类的取钱方法,因为每个线程都要进入这个方法,我们可以拿到这个线程的名字

下面我们创建一个线程类,run里面要把握住,这个线程的行为,因为我们要完成取钱,所以必须有一个账户对象,我们要构建一个有参构造器,来接收对那个账户进行操作,还要接受线程的名字

package surf_Thread;

public class DrawMoney extends Thread{
    private Account acc;
    public DrawMoney(Account acc,String name)
    {
        super(name); // super 要放到上面
        this.acc = acc;
    }
    @Override
    public void run()
    {
        //run里面主要实现线程要完成什么事情
        acc.drawMoney(100000);
    }
}

主线程

package surf_Thread;

public class ThreadTest {
    public static void main(String[] args) {
        // 1. 创建一个账户,两个人共同的对象
        Account acc = new Account("ICBC-120",100000);
        // 2.创建取钱线程
        new DrawMoney(acc,"小明").start();
        new DrawMoney(acc,"小红").start();


    }
}

我们对这个案例运行时,发现:

这个就会造成线程安全问题

我们应该怎么解决呢?

看下面

线程同步

同步代码块

建议使用共享资源作为锁对象,对于实例方法建议使用this作为锁对象

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

同步方法

有隐含this

Lock锁

线程池

JDK 5.0起提供了代表线程池的接口: ExecutorService

但是利用接口我们是不能创建线程池对象的,那我们如何得到线程池对象?

线程池对象的创建方式一:

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

需要我们注意的是:

1.临时线程什么时候创建?

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

2.什么时候会开始拒绝新任务?

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

下面是创建线程池

import java.util.concurrent.*;

public class Pool {
    public static void main(String[] args) {
        ExecutorService Pool = new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory()
                ,new ThreadPoolExecutor.AbortPolicy());
        
    }
}

线程池处理Runnable任务

下面是4中不同形式的任务拒绝策略

public class Pool {
    public static void main(String[] args) {
        ExecutorService Pool = new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory()
                ,new ThreadPoolExecutor.AbortPolicy());
        Runnable target = new MyRunnable();
        Pool.execute(target); // 线程池自动创建一个新线程,自动处理这个任务,自动执行
        Pool.execute(target); // 线程池自动创建一个新线程,自动处理这个任务,自动执行
        Pool.execute(target); // 线程池自动创建一个新线程,自动处理这个任务,自动执行
        Pool.execute(target); // 复用上面的线程
        Pool.execute(target); // 复用上面的线程 // 注意临时线程的创建条件:核心线程都占用了,而且队列中都占满了
        // 如果想要创建临时线程,让上面的线程都被占用,而且队列占满
        //假如说现在满足条件,那么下面添加任务就开始创建临时线程
        Pool.execute(target);
        Pool.execute(target);  // 上面创建了两个临时线程
        // 如果再有任务那么就直接拒绝
        
    }
}

因为线程池创建之后开始运行,他不能自动关闭,我们一般情况下也不希望它关闭

那么怎么让他关闭呢?

两种方法:

线程池处理Callable任务

package ThreadPoolTest;

import java.util.concurrent.*;

public class Pool {
    public static void main(String[] args) throws Exception {
        ExecutorService Pool = new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory()
                ,new ThreadPoolExecutor.AbortPolicy());
        Future<String> f1 = Pool.submit(new MyCall(100));
        Future<String> f2 = Pool.submit(new MyCall(200));
        Future<String> f3 = Pool.submit(new MyCall(300));

        String s1 = f1.get();
    }
}