13.Java多线程

概念

并发与并行

并发：指两个或多个事件在同一时间段内发生

并行：指两个或多个事件在同一时刻发生(同时发生)

线程与进程

进程：是指一个内存中运行的应用程序

线程：线程是进程中的一个执行单元，一个进程至少有一个线程

创建线程类

主线程：执行主(main)方法的线程

单线程程序：java程序只有一个线程
执行从main方法开始 从上到下依次执行

Thread

步骤：

1. 创建Thread类的子类
2. 在子类中重写run()方法 设置线程任务
3. 创建子类对象
4. 调用Thread类中的start()方法，开启新线程，执行run方法

start()：使该线程开始执行，java虚拟机调用该线程的run()方法

//创建Thread类的子类
public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i = 0;i<20;i++){
            System.out.println("run:"+i);
        }
    }
}


public class ThreadDemo {
    public static void main(String[] args) {
    //创建子类对象
        MyThread myThread = new MyThread();
        myThread.start();

        for(int i = 0;i<20;i++){
            System.out.println("main:"+i);
        }
    }
}

Thread 常用方法

获取线程名称：

• Thread类中的getName()方法
• 获取当前执行的线程，使用线程中的方法getName()，currentThread()返回当前执行线程的引用

 @Override
    public void run() {
        String name = getName();
        System.out.println(name);
    }
  
  //可以在主方法(main里)输出打印main线程名字  
   System.out.println(Thread.currentThread().getName());

设置线程名称：

1. 使用Thread类中的setName()方法
2. 创建带参数的构造方法，参数传递线程的名称，调用父类的带参构造方法，把线程名字传递给父类

sleep： 使当前执行的线程以指定的毫秒数暂停

创建线程第二种方法 实现Runnable接口

Thread类的构造方法可以传递Runnable实现类对象

实现步骤：

1. 创建一个Runnable接口的实现类
2. 在实现类中重写Runnable接口的run方法
3. 创建一个Runnable接口的实现类对象
4. 创建一个Thread类对象，构造方法中传递Runnable接口的实现类对象
5. 调用Thrad类中的start()方法

//创建一个Runnable接口的实现类
public class RunnableImpl implements  Runnable {
    //在实现类中重写Runnable接口的run方法
    @Override
    public void run() {
        for (int i = 0;i<20;i++){
            System.out.println(i);
        }
    }
}

 public static void main(String[] args) {
        //创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建一个Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);
        //调用Thrad类中的start()方法
        t.start();
    }

Thread 与 Runnable区别

实现Runnable接口创建多线程的好处：

1. 避免了单继承 （实现了Runnable 还能继承其他类）
2. 增强了程序的扩展性（设置线程任务和开启新线程进行分离）

匿名内部类创建线程

简化代码

格式：

new 父类/接口(){

重写父类/接口方法

};

  public static void main(String[] args) {
        //线程的父类是Thread
        new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"KK");
            }
        }.start();

        //线程的接口Runnable
        Runnable r = new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"RR");
            }
        };
        new Thread(r).start();

        //简化Runnable
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"R");
            }
        }).start();

    }

线程安全问题

单线程不会出现线程安全,多个线程对象操作共享资源就可能会出现线程安全问题

解决线程安全：

同步代码块:

synchronized(锁对象){
    可能出现线程安全问题的代码
}

注意：

1. 通过代码块中的锁对象(可以是任意一个)
2. 必须保证多个线程使用的锁对象是同一个
3. 锁对象作用：把同步代码块锁住，只让一个线程在执行

同步技术：使用一个锁对象（同步锁），同步中的线程，没用执行完毕不会释放锁，
没有锁的线程进不去同步

同步方法

1. 把访问共享数据的代码抽取出来，放在一个方法中
2. 在方法上添加synchronized修饰符

修饰符 synchronized void 方法名(){
    可能出现线程安全问题的代码
}

静态同步方法

锁对象：本类的class属性

修饰符 static  synchronized void 方法名(){
    可能出现线程安全问题的代码
}

Lock锁

lock()：获得锁

unlock():释放锁

使用步骤：使用它的实现类 ReentrantLock

1. 在成员位置创建一个ReentrantLock对象
2. 在可能会出现线程问题的代码前调用Lock接口的lock获取锁
3. 在可能会出现线程问题的代码后调用Lock接口的unlock释放锁

线程的状态

六种状态：

1. New(新建状态 new Thread)
2. Runnable (运行状态)
3. Blocked(阻塞状态)
4. waiting(等待状态)
5. time_waiting(休眠状态)
6. Teaminated(退出状态)