关于java线程

Hypnos924

于 2022-06-06 02:20:21 发布

阅读量545

点赞数 4

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_42588032/article/details/125139750

版权

线程

要说线程，我们就需要先明白下面这几个概念

线程和进程：

进程：一个应用程序就是一个或多个进程

线程：一个进程有一个或多个线程。

多线程：

好处：发挥多核cpu的效率（线程不能独立，其依附于进程）

并发和并行

并发：（必须是多核cpu才可以达到）：一个或多个事件（任务）在同一个时间点（同时执行）

调度方式

抢占调度：给每个任务分配的时间不等

分时调度：给每个任务分配的时间是均等的

（java虚拟机默认使用的是抢占调度）

线程

一个Thread类对象就是一个线程

Thread类

构造方法：

public Thread();

public Thread(String name);

public Thread(Runnable target);

public Thread(Runnable target,String name);

成员变量：

private Runnable target；

静态方法：

static Thread currentThread();

成员方法:

void start();启动线程后，会执行run方法中的代码

void run(){

if(target!==null){

target.run();

}

};

String getName();

void steName(String name);

Runnable接口

public abstract void run();

Runnable接口的方式和继承Thread类的方式：建议使用Runnable方式

线程和任务分离，解耦合，提高代码的健壮性。
避免了java单继承的局限性
线程池里面，只能传入Runnable或者Callable类型对象，不用new Thread对象

每一个线程启动后都会有一个栈，各自在各自的栈中执行任务。

线程的开销比一般的对象开销要大

多个线程执行时，谁线程执行不确定，谁执行多长时间不确定*

例子：（继承Thread类的方式）

SubThread类

public class SubThread extends Thread{
    @Override
    public void run() {
        //获取当前线程，执行当前线程代码
        Thread t = Thread.currentThread();
        //获取当前线程的名字
        String name = t.getName();
        for (int i = 0; i < 10; i++) {
            System.out.println(name+" "+i);
        }
    }

test测试类

public class test2 {
    public static void main(String[] args) {
        Thread t = new SubThread();
        t.start();
        Thread m = Thread.currentThread();
        String name = m.getName();
        for (int i = 0; i < 10; i++) {
            System.out.println(name+" "+i);
        }
    }
}
输出：
main 0
Thread-0 0
main 1
main 2
main 3
main 4
main 5
Thread-0 1
main 6
Thread-0 2
main 7
main 8
main 9
    （部分输出）

Runnable方式

public static void main(String[] args) {
       //创建一个Runnable类型的对象
        Runnable r =new Runnable() {
           @Override
           public void run() {
               Thread a = Thread.currentThread();
               String name = a.getName();
               System.out.println(name);
           }
       };
        //把Runnable类型对象，赋值给Thread类的成员变量target，并给线程起名为“线程1”
       Thread t = new Thread(r,"线程1");
       t.start();
    }

这个例子也可以用lambda表达式来写

public static void main(String[] args) {
        Runnable r = () -> {
           System.out.println(Thread.currentThread().getName());
        };
       new Thread(r,"线程1").start();
    }

线程安全

在多个资源访问同一个资源（数据）时会产生线程安全问题

整个操作不是原子操作

例子：

 static int m = 0;
    public static void main(String[] args) throws InterruptedException {
        //创建一个Runnable类型的对象
        Runnable r = () -> {
            for (int i = 0; i < 10000; i++) {
                m++;
            }
        };
        //把Runnable类型对象，赋值给Thread类的成员变量target，并给线程起名为“线程1”
       new Thread(r).start();
       new Thread(r).start();
       Thread.sleep(300);
        System.out.println(m);
    }
输出：14626

解决办法

1.使用synchronized代码块

语法：

synchronized（锁对象）{

//有可能发生线程安全问题的代码

}

2.使用synchronized方法

3.使用lock锁

例子：

synchronized代码块

static int m = 0;
    public static void main(String[] args) throws InterruptedException {
        //创建一个Runnable类型的对象
        Runnable r = new Runnable() {
            @Override
            public void run() {
                synchronized (this){
                    for (int i = 0; i < 10000; i++) {
                        m++;
                    }
                }
            }
        };
       new Thread(r).start();
       new Thread(r).start();
       Thread.sleep(300);
        System.out.println(m);
    }
输出：20000

synchronized方法

static int m = 0;
    public static void main(String[] args) throws InterruptedException {
        //创建一个Runnable类型的对象
        Runnable r = new Runnable() {
            @Override
            public void run() {
                synchronized (this){
                    for (int i = 0; i < 10000; i++) {
                        add();
                    }
                }
            }
        };
       new Thread(r).start();
       new Thread(r).start();
       Thread.sleep(300);
        System.out.println(m);
    }
    public static synchronized void add(){
        m++;            
    }
输出：20000

lock锁

static int m = 0;
    public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock();
        //创建一个Runnable类型的对象
        Runnable r = new Runnable() {
            @Override
            public void run() {
                synchronized (this){
                    for (int i = 0; i < 10000; i++) {
                        lock.lock();
                        m++;
                        lock.unlock();
                    }
                }
            }
        };
       new Thread(r).start();
       new Thread(r).start();
       Thread.sleep(300);
        System.out.println(m);
    }
输出：20000

线程的状态

NEW：新建状态。创建了一个新线程，启动之前处于该状态

RUNNABLE：可运行状态

BLOCKED：阻塞状态

WAITING：无限等待状态

TIMED_WAITING：计时等待状态

TERMINATED：消亡状态

public static void main(String[] args) {
        Thread t = new Thread();
       //获取线程的状态
        Thread.State s = t.getState();
        System.out.println(s);//NEW
    }
输出：NEW

线程的通信

多个线程在处理同一资源，但是处理动作（线程的任务）却不同

比如：线程A用来生产包子，线程B用来吃包子，包子可以理解为同一资源，线程A与B处理的动作，一个是消费一个是生产，那么A，B之间就存在线程间的通讯

等待唤醒机制

我们需要通过等待唤醒机制使各个线程能有效的利用资源，避免在多个线程处理同一变量时发生争夺。

object类

void wait();//让线程进入等待状态

void wait(long time);//调用该方法，会让线程进入计时等待状态

void notify();//调用该方法，会让线程醒来，接着执行任务

void notifyAll();//调用该方法，会唤醒当前锁对象上等待的所有进程

注意：

1.这些方法都必须写在synchronized代码块或者synchronized方法中

2.调用这些方法的对象，必须和锁对象一致。

3.t.notify方法只能唤醒“t”锁对象上等待的线程

4.调用了wait（不论是否有参数）方法，会自动释放锁对象

我们来用“生产者与消费者”的问题来说明等待唤醒机制

包子铺生产包子，吃货吃包子，当包子没有时（false状态），吃货（消费者线程）等待，包子铺（生产者线程）开始生产包子（包子状态为true）并通知吃货（接触吃货的等待状态），包子铺线程进入等待状态。接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完（包子状态为false），并通知包子铺线程（解除包子铺的等待状态）,吃货线程进入等待。包子铺线程能否进一步执行则取决于锁的获取情况。

baozi类

public class baozi{
     public boolean flag;//有没有包子，有包子为true没包子为false
}

吃货线程（消费者）

package exc1;
public class chihuo extends Thread{
    private baozi bz;
    public chihuo(baozi bz) {
        super();
        this.bz = bz;
    }
    public void run(){
        while (true){
            synchronized (bz){
                //判断是否有包子
                if (bz.flag){
                    //有包子就吃包子
                System.out.println("吃货正在吃包子");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                    //吃完包子，改变包子的状态
                bz.flag = false;
                    //唤醒等待的线程
                bz.notify();
            }else {
                try {
                    //没有包子，等待
                    bz.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            }

        }
    }
}

包子铺线程（生产者线程）

package exc1;

public class baozipu extends Thread {
    private baozi bz;
    public baozipu(baozi bz){
        super();
        this.bz = bz;
    }
     public void run(){
        while (true){
            synchronized (bz){
                //判断是否有包子
                if (bz.flag){
                    try {
                        //有包子，不生产，等待
                        bz.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else {
                    //没有包子，生产包子
                    System.out.println("包子铺没有包子正在生产包子");
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    //改变包子的状态
                    bz.flag=true;
                    //唤醒等待的线程
                    bz.notify();
                }
            }
        }
     }
}

测试类

public class test {
    public static void main(String[] args) {
        baozi bz  = new baozi();
         new chihuo(bz).start();
         new baozipu(bz).start();

    }
}
输出：
包子铺没有包子正在生产包子
吃货正在吃包子
包子铺没有包子正在生产包子
吃货正在吃包子
包子铺没有包子正在生产包子
吃货正在吃包子
包子铺没有包子正在生产包子（部分输出）.....

线程池

我们使用线程就去创建一个线程，这样实现起来很简单，但是如果需要并发很多线程，那么系统资源就会被频繁的创建线程和销毁线程消耗

这时候就需要线程池：

1.降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被利用，可以执行多个任务。

2.提高响应速度。当任务达到时，任务可以不需要的等到线程就能创建就能立即执行

3.提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线程的数目

Executors类

static ExecutorService newFiexdThredadPool(int nThread);

ExecutorService接口：

void execute(Runnable r);//执行任务

Future submit(Callable c);

Future<?> submit(Runnable r);

void shutdown();//关闭线程池

Future接口

T get();//必须等子线程把任务执行完成，return以后才可以获取返回的结果。

Callable接口：

T call();

创建线程池的步奏

1.创建线程池对象

2.创建Runnable接口子类对象

3.提交Runnable接口子类对象

4.关闭线程池（一般不做这一步）

例子：

public class test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        //创建一个固定线程池对象
        ExecutorService es = Executors.newFixedThreadPool(2);
        //Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。
        Future<?> future = es.submit(r);
        Object result = future.get();//null
        System.out.println(result);
        //关闭线程池
        es.shutdown();
    }
}