JAVA-day11

一、目的

学习进程和线程的概念
学会实现Runnable接口创建线程
了解synchronized线程同步
学会使用Lock加锁
使用接口实现主线程和子线程的数据回调

二、相关技术

1.多线程

进程:正在运行的一个程序QQ IDE 浏览器
系统会为这个进程分配独立的内存资源
线程:具体执行任务的最小单位
一个进程最少拥有一个线程（主线程运行起来就执行的线程）
线程之间是共享内存资源的（经常申请的）
线程之间可以通信（数据传递:多数为主线程和子线程）
每一个线程都有自己的运行回路（生命周期）
线程的生命周期状态
NEW:新建线程刚被创建好
RUNNABLE:就绪状态只要抢到时间片就可以运行这个线程
BLOCKED:阻塞状态 sleep wait
WAITING:等待 wait
TIMED_WAITING,
TERMINATED:终止

1.如何创建一个线程 Thread Runable
2.线程的同步 synchronized ReentrantLock
3.主线程和子线程之间使用接口回调数据
4.线程间的通信:synchronized（wait notifi notifiall）
ReentrantLock lock;
Condition c=lock.newCondition();
await single songleall

2. 为什么需要创建子线程

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

3.如何创建一个子线程

1.定义一个类继承于Thread 实现run方法

join:让当前这个线程阻塞等join的线程执行完毕再执行
setName:设置线程名称
getName:获取线程名称
currentThread:获取当前运行的线程对象
start:开启任务

2.实现Runnable接口实现run方法
a.创建任务创建类实现Runnable
b.使用Thread 为这个任务分配线程
c.开启任务 start

4.线程安全

synchronized Lock 加锁解锁
synchronized 同步监听器需要一把锁
任何一个对象都有自己的一把锁
如果多个线程操作同一个代码块，并且需要同步
那么必须操作同一个对象/同一个对象的同一把锁
1.同步代码块
synchronized（监听器/对象/锁）{
需要同步的代码
}
2.同步方法
public synchronized void test(){}
本质是同步代码块等价于
synchronized（this）{
test();
}

三、技术的使用

1.使用继承Thread创建线程

class TestThread extends Thread {
    //实现Run方法
    //方法里面就是具体需要执行的代码
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name);
        for (int i = 0; i < 100; i++) {
            System.out.println(name + ":" + (i + 1));
         }
         super.run();
    }
}

2.创建线程

        TestThread tt=new TestThread();
        //设置线程的名称
        tt.setName("子线程1");
        //开启任务
        tt.start();

        TestThread tt2=new TestThread();
        //设置线程的名称
        tt2.setName("子线程2");
        //开启任务
        tt2.start();

3.实现Runnable接口创建线程

class YThread implements Runnable{
    public void run() {
        for (int i = 1; i <=100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

4.Runnable接口使用方式

(1)

        //创建一个任务:创建一个类实现Runnable接口
        YThread yt=new YThread();
        //使用Thread操作这个任务
        Thread t=new Thread(yt);
        t.setName("子线程1");
        t.start();
        Thread t2=new Thread(yt);
        t2.setName("子线程2");
        t2.start();

(2)

Thread t=new Thread(new Runnable()){
           @Override
            public void run() {
                for (int i = 1; i <=100 ; i++) {
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
}
t.setName("子线程1");
t.start();

(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)

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

5.使用RuntrantLock同步

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

 for (int i = 1; i <=100 ; i++) {
            //加锁
            lock.lock();
            if (num>0){
                System.out.println(name+"出票"+num);
                num--;
               try {
                   condition.signal();
                   condition.await();
               }catch (InterruptedException e){
                   e.printStackTrace();
               }finally {

               }
            }else {
                break;
            }
            //解锁
            lock.unlock();
        }
    }