多线程2019-08-19

目的:多线程是知识体系中一重要的部分,使用多线程能同步完成多个任务,提高资源使用效率进而提高系统的效率。

线程所需掌握知识点:

  • 1.如何创建一个线程 Thead Runnable
  • 2.线程的同步
  • 3.主线程与子线程之间使用接口回调数据
  • 4.线程之间的通信 :
    synchronized (wait notify notifyALL)

ReentrantLock lock;
Condition c = lock.newCondition()
await single singleALL

技术:

1.基本知识点:

(1)进程和线程

进程:正在运行的一个程序QQ IDE 浏览器
系统会为这个进程分配独立的内存资源
线程:具体执行任务的最小单位
一个进程最少拥有一个线程(主线程 运行起来就执行的线程)
线程之间是共享内存资源的(进程申请的)
线程之间可以通信(数据传递:多数情况下为主线程和子线程)
每一个线程都有自己的回路(生命周期)

(2)线程的生命周期 状态
6441157D1DFF7B3DA414078385811477.jpg
     NEW:新建 线程刚被创建好
     RUNNABLE: runnable 就绪状态 只要抢到时间片就可以运行这个线程
     BLOCKED :阻塞状态  sleep
     WAITING :等待     wait
     TIMED_WAITING
     TERMINATED :终止
(3)为什么需要创建子线程

如果在主线程中存在比较耗时的操作:下载视频 上传文件 数据处理
这些操作会阻塞主线程 后面的任务必须等这些任务执行完毕
之后才能执行,用户体验感差
为了不阻塞主线程,需要将耗时的任务放在子线程里面去执行

2.如何创建子线程:

(1)写一个类继承于Thread 实现run方法
  • join: 让当前这个线程阻塞,让join的线程执行完毕再执行
  • setName:设置线程名称
  • getName:获取线程名称
  • currentThread:获取当前线程的线程对象
  • start:开启任务
    eg:
class TextTHread extends Thread{
    //实现run方法
    //方法里面就是具体需要执行的代码
    @Override
    public void run(){
        String name = Thread.currentThread().getName();
        for (int i = 0; i < 100; i++) {
            System.out.println(name+":"+(i+1));
           
        }
        super.run();
    }
}

创建线程:

 //main方法里面执行的代码 是在主线程里面执行的
        //主线程的名称是main (不是main方法)
        //System.out.println(Thread.currentThread().getName());

        //创建Thread对象
        TextTHread textTHread1 = new TextTHread();
        //设置线程名称
        textTHread1.setName("子线程1");
        //开启任务
        textTHread1.start();

        textTHread2 = new TextTHread();
        //设置线程名称
        textTHread2.setName("子线程2");
        //开启任务
        textTHread2.start();
(2).实现Runnable接口 实现run方法
  • a.创建任务 创建类实现Runnable接口
  • b.使用Thread 为这个任务分配线程
  • c.开启任务 start
    eg:
class PXDThread implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <=100; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

调用方法1:

//2.1
        PXDThread pt = new PXDThread();
        //使用Thread操作这个任务
        Thread t = new Thread(pt);

        t.setName("子线程1:");
        t.start();

        Thread t2 = new Thread(pt);//一个任务可以由多个线程完成啊
        t2.setName("子线程2:");
        t2.start();

调用方法2:

 //2.2
        //这个任务只需要使用一次
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=100; i++) {
                    System.out.println(Thread.currentThread().getName()+i);
                }
            }
        });
        t1.setName("子线程1:");
        t1.start();

调用方法3:

//2.3
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=100; i++) {
                    System.out.println(Thread.currentThread().getName()+i);
                }
            }
        }).start();

调用方法4:

 //2.4
        //使用Lambda表达式
        //不建议 阅读性太差
        new Thread( () -> {
            for (int i = 1; i <=100; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }).start();

3.线程安全:同步

    线程安全  synchronized Lock  加锁解锁
    synchronized 需要同步监听器 需要一把锁
    任何对象都有一个把锁
    如果多个线程操作同一一个代码块,并且需要同步
    那么就需要操作同一个对象/同一个对象的同一把锁
    synchronized(监听器/对象/锁)

eg:火车票卖票 全国的卖票系统就一个

(1)synchronized:

synchronized(监听器/对象/锁)
1.同步代码块
synchronized(监听器/对象/锁){
需要同步的代码
}

//用于卖票的任务
class Ticket implements Runnable{
    //定义所有车票的数量
    public static  int num = 100;
    String name;
    public Ticket(String name){
        this.name = name;
    }
    static final Object obj =new Object();

    //创建一个可重新载入的锁
    static ReentrantLock lock = new ReentrantLock();

    public void run() {
        for(int i =1;i<=100;i++){
            //判断有没有票
            synchronized (obj){
                //需要同步的代码
                if (num>0){
                    System.out.println(name+"出票:"+(101-num));
                    num--;
                    try {
                        //当前线程等待
                        obj.notify();
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }

        }
    }
}
(2)Lock:

2.同步方法 同步监听器就是当前对象本身
必须保证多个对象调用的同步方法时操作的统一对象
public synchronized void text(){
本质就是同步代码块
等价于
synchronized(this) {
text();
}

以下代码中未实现await single singleALL等线程状态转换方法

//用于卖票的任务
class Ticket implements Runnable{
    //定义所有车票的数量
    public static  int num = 100;
    String name;
    public Ticket(String name){
        this.name = name;
    }
    static final Object obj =new Object();

    //创建一个可重新载入的锁
    static ReentrantLock lock = new ReentrantLock();

    Condition condition = lock.newCondition();
    public void run() {
        for(int i =1;i<=100;i++){
            //判断有没有票
//            synchronized (obj){
//                //需要同步的代码
            //加锁
            lock.lock();
                if (num>0){
                    System.out.println(name+"出票:"+(101-num));
                    num--;
                    lock.newCondition();
                }else{
                    break;
                }
            //解锁
            lock.unlock();
        }
    }
}

调用:

//        火车票卖票
//        全国的卖票系统就一个
        Ticket ticketCQ = new Ticket("重庆");
        Thread t1 = new Thread(ticketCQ);
        t1.start();

        Ticket ticketSH = new Ticket("上海");
        Thread t2 = new Thread(ticketSH);
        t2.start();

运行结果太长,不予展现。

4.使用接口实现线程之间数据回调

(1)定义线程里面 Agent类
public class Agent extends Thread{
    AgentInterface target;

    @Override
    public void run() {
        System.out.println("开始找房子");
        System.out.println("---------");
        System.out.println("房子找到了 即将返回数据");

        target.callBack("房子在XXX");
        super.run();
    }

    public interface AgentInterface{
        void callBack(String desc);
    }

}
(2)定义Person类:
public class Person implements Agent.AgentInterface {


    public void needHouse(){

        Agent xw = new Agent();
        xw.target = this;   //表明返回数据给调用者
        xw.start();
    }

    @Override
    public void callBack(String desc) {
        System.out.println("我是小王,接受到你的数据"+desc);
    }
}
(3)调用:
 Person person = new Person();
        person.needHouse();
运行结果:
开始找房子
---------
房子找到了 即将返回数据
我是小王,接受到你的数据房子在XXX

Process finished with exit code 0

心得:

java的学习要接近尾声了,我越来越认识到自己前面的知识点有些力不从心,比如代理设计模式,哎,得好好去复习了。

你可能感兴趣的:(多线程2019-08-19)