了解多线程、三种创建多线程的方式以及一些方法

概念

多线程：多条路径同时进行，那么说明有多个任务，多任务是开启线程的初衷，只有一个任务就不需要开启
 *   多线程了。现实生活中，我们可以边看手机边吃饭，看似是同时进行，但是实际上，在一个时间点（这
 *   个时间点是指不可分割的）我们的大脑只能做一件事。电脑也是一样，一个CPU在一个时间点只能做一
 *   个任务，因为切换的很快，所以有同时进行的错觉；真正的多线程是指有多个CPU，即多核才能做不同的事
 *   情，比如服务器。
 * 普通方法的调用是单线程，从哪里来到哪里去，闭合的一条路径；多线程的使用开辟了多条并行的路径。
 * 进程与线程：1.在操作系统中运行的程序就是进程，一个进程可以有多个线程，比如看视频的同时听声音、
 *   显示字幕、看图像。
 *           2.进程是系统作为资源分配的单位，线程是CPU调度执行的单位。
 *           3.每个进程有独立的代码和数据空间，进程间的切换开销会比较大；线程可以看成是轻量级的进程，
 *           同一类的线程共享代码和数据空间，每个线程有独立的运行线和程序计数器，线程切换开销小。
 *           4.在操作系统中能同时运行多个程序；在同一个程序中有多个顺序流同时执行。
 *           5.系统运行时会为每个进程分配不同的内存区域；除了CPU，不会为线程程分配内存。
 *要点：1.线程是指独立的执行路径，多线程指多条不同的独立的执行路径。
 *     2.在程序运行时，即使自己没有创建线程，后台也会有多个线程，比如主线程、GC线程。
 *     3.main()是主线程，为系统的入口，用于执行整个程序。
 *     4.在一个进程中，如果开辟了多个线程，线程的运行有调度器安排调度，调度器与操作系统紧密相关，
 *     先后顺序不能人为干预。
 *     5.对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
 *     6.线程会带来额外的开销，如CPU调度时间、并发开销
 *     7.每个线程有自己的工作内存，线程的工作内存和主存之间的交互控制不当会造成数据不一致

创建线程的三种方式：1.继承thread类；2.实现runnable接口;3.实现callable接口。前两种现在用的多，
 *     少用继承，多用实现，因为类有单继承的局限性。callable是高级并发编程JUC的一部分，需要有几年
 *     工作经验了再去学就比较好上手；runnable实现的是RUN方法，callable实现的是CALL方法，比起RUN
 *     方法，可以抛异常，有返回值，需要借助服务以及线程池，更强大当然也更麻烦，现在只需要了解。

方式一：

public class TestSetUpThread extends Thread{

    /*
    线程入口点
     */
    @Override
    public void run() {
        for (int i = 0; i <30 ; i++) {
            System.out.println("一边吃饭");
        }
    }

    public static void main(String[] args) {
        //创建线程
        TestSetUpThread tst = new TestSetUpThread();
        /*
        这个是把线程加入到调度器,不保证立即运行，系统安排调度分配执行
        start会自己调用run方法。
         */
        tst.start();
       // tst.run();//普通方法的调用
        for (int i = 0; i < 30; i++) {
            System.out.println("一边玩手机");
        }
    }
}

方式二：

实现Runnable接口
 * 模拟抢票，共享资源
public class TestRunnable implements Runnable{
    private int ticketNums = 20;//票数
    private String name;
    private boolean  flag = true;

    public TestRunnable(String name) {
        this.name = name;
    }

    @Override
   public void run() {
       while(flag) {
           if(ticketNums<0){
               flag = false;
               return;
            }
            try {
                Thread.sleep(200);//模拟网络延迟，可能会有并发问题，数据错误
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
               Thread.currentThread().getName();//拿到当前线程的名字
                      System.out.println(Thread.currentThread().getName()+"-->"+name+ticketNums--);
      }
   }
    public static void main(String[] args) throws InterruptedException {
        TestRunnable runnable = new TestRunnable("张三");
         new Thread(runnable,"小白").start();
        new Thread(runnable,"小华").start();
        new Thread(runnable,"小明").start();
    }
}

运行之后会发现结果有负数，这就是并发问题。这里可以解决这个并发问题。

方式三：也是模拟抢票

public class TestCallable implements Callable<Boolean>{
    @Override
    public Boolean call() throws Exception {
         int ticketNums = 99;//票数
        while(true){
            if(ticketNums<0){
                break;
            }
            //Thread.currentThread().getName()拿到当前线程的名字
            System.out.println(Thread.currentThread().getName()+"------->"+ticketNums--);
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> result1 = ser.submit(new TestCallable());
        Future<Boolean> result2 = ser.submit(new TestCallable());
        Future<Boolean> result3 = ser.submit(new TestCallable());
        //获取结果
        boolean r1 = result1.get();
        boolean r2 = result2.get();
        boolean r3 = result3.get();
        //关闭服务
        ser.shutdownNow();

    }
}

一些方法：

1.isAlive:判断线程是否终止；
 *           2.setName:给线程起名字；getName:获取线程名，这里的名称是代理的名称，
 *           自己真实的名称通过面向对象来设置
 *          3. currentThread:获取线程本身

System.out.println(Thread.currentThread().isAlive());
 new Thread(new TestRunnable()).start();只使用一次的时候这么写，这里的TestRunnable就是上面方式一的那个类
TestRunnable runnable = new TestRunnable("张三");这里是面向对象设置的真实名字
new Thread(runnable,"小白").start();这是代理名字
Thread.currentThread().getName()；这个获取的是代理的名字