异常与多线程(二)

一、线程

Java提供了三种创建线程方法：

通过实现Runnable接口
通过继承Thread类本身
通过 Callable 和 Future 创建线程

1. Thread类

构造方法

public Thread() ，分配一个新的线程对象
public Thread(String name) ，分配一个指定名字的新的线程对象
public Thread(Runnable target) ，分配一个带有指定目标新的线程对象
public Thread(Runnable target,String name) ，分配一个带有指定目标新的线程对象并指定名字

常用方法

public String getName() ，获取当前线程名称
public void start() ，导致此线程开始执行; Java虚拟机调用此线程的run方法
public void run() ，此线程要执行的任务在此处定义代码
public static void sleep(long millis) ，使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）

public class Demo01Sleep {
    public static void main(String[] args) {
        //模拟秒表
        for (int i = 1; i <=60 ; i++) {
            System.out.println(i);

            //使用Thread类的sleep方法让程序睡眠1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public static Thread currentThread() ，返回对当前正在执行的线程对象的引用

查看API后得知创建线程的方式有两种，一是继承Thread类方式，二是实现Runnable接口方式

2. Runnable类

java.lang.Runnable，创建多线程程序的第二种方式：实现Runnable接口，我们只需要重写run方法即可

构造方法：

Thread(Runnable target) 分配新的 Thread 对象
Thread(Runnable target, String name) 分配新的 Thread 对象

实现步骤：

创建一个Runnable接口的实现类
实现类中重写Runnable接口的run方法，设置线程任务
创建一个Runnable接口的实现类对象
创建Thread类对象，构造方法中传递Runnable接口的实现类对象
调用Thread类中的start方法，开启新的线程执行run方法

实例：

    public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);//打印线程名称
        //Thread t = new Thread(new RunnableImpl2());//打印HelloWorld
        //5.调用Thread类中的start方法,开启新的线程执行run方法
        t.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

public class RunnableImpl implements Runnable {
    //2.在实现类中重写Runnable接口的run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

}

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

避免了单继承的局限性
- 一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
- 实现了Runnable接口,还可以继承其他的类,实现其他的接口
实现了Runnable接口,还可以继承其他的类,实现其他的接口
- 实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)
- 实现类中,重写了run方法：用来设置线程任务
- 创建Thread类对象,调用start方法：用来开启新线程

注意：

Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。
而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法

3. Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享

实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源
可以避免java中的单继承的局限性
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，其实在就是在操作系统中启动了一个进
程

4. 匿名内部类方式实现线程的创建

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作

匿名：没有名字
内部类：写在其他类内部的类

匿名内部类作用：简化代码

把子类继承父类,重写父类的方法,创建子类对象合一步完成
把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成

匿名内部类的最终产物：子类/实现类对象，而这个类没有名字

格式：

new 父类/接口(){
            重复父类/接口中的方法
        };

实例：

public class Demo01InnerClassThread {
    public static void main(String[] args) {
        //线程的父类是Thread
        // new MyThread().start();
        new Thread(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"你好");
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl();//多态
        Runnable r = new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"程序员");
                }
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"匿名内部类");
                }
            }
        }).start();
    }
}

二、线程安全

1. 线程安全

如果有多个线程在同时运行，这些线程可能会同时运行一段代码。程序每次运行结果和单线程运行的结果是一样的，且其他的变量的值也和预期的是一样的，线程就称为是安全的。若线程不同步，就称为线程不安全，如下面这个例子：

模拟电影院的卖票过程，座位共100个。

模拟票：

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

测试类：

/*
    实现卖票案例
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;


    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

程序运行结果出现了线程安全问题，卖出了不存在的票和重复的票，可以用线程同步解决

2. 线程同步

当使用多个线程访问同一资源的时候，若多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题：也就是解决重复票与不存在票问题，Java中提供了同步机制来解决

对上面的实例而言：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。
也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象

为了保证每个线程都能正常执行原子操作，解决线程安全问题，有三种方案可以选择：

同步代码块
同步方法
锁机制

3. 同步代码块

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问
格式：

synchronized(同步锁){
	需要同步操作的代码
}

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
           //同步代码块
            synchronized (obj){
                //先判断票是否存在
                if(ticket>0){
                    //提高安全问题出现的概率,让程序睡眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //票存在,卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                }
            }
        }
    }
}

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

注意：

通过代码块中的锁对象,可以使用任意的对象
但必须保证多个线程使用的锁对象是同一个
锁对象作用：
- 把同步代码块锁住,只让一个线程在同步代码块中执行

4. 同步方法

同步方法：使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着

使用步骤：

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

格式：

修饰符 synchronized 返回值类型 方法名(参数列表){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
}

5. 静态的同步方法

解决线程安全问题的二种方案：使用同步方法

使用步骤:

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

格式:定义方法的格式
修饰符 synchronized 返回值类型方法名(参数列表){
可能会出现线程安全问题的代码(访问了共享数据的代码)

6. Lock锁

解决线程安全问题的三种方案：使用Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有且更强大，更能体现面向对象的特点。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

java.util.concurrent.locks.Lock接口，Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

Lock接口中的方法:

```

void lock()获取锁
void unlock() 释放锁
java.util.concurrent.locks.ReentrantLock implements Lock接口
```