JavaSE（2）01 多线程--线程简介

多线程

线程简介

Process和Thread

• 进程和程序
  程序是指令和数据的有序集合，程序是静态的，进程是执行程序的一次执行过程，进程是动态的，是系统资源分配的基本单位（线程是调度的基本单位）
• 进程和线程
  通常一个进程中可以包含若干个线程，进程中至少包含一个线程（main线程），线程是CPU调度和执行的基本单位
  注意：很多多线程都是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一时间点，CPU只能执行一个代码，因为线程切换的快，所以给人同时执行的错觉。
• 核心概念
  • 线程是独立的执行路径
  • 在程序运行时，即使自己没有创建线程，后台也会有多个线程，如main线程，gc线程；
  • main()称之为主线程，为系统的入口，用于执行整个程序
  • 在一进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预
  • 对同一份资源操作时，会存在资源抢夺问题，需要加入并发控制
  • 线程会带来额外的开销，如CPU调度时间，并发控制开销
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程的创建

方式一

• 继承Thread
• 重新run()方法
• 创建线程对象，调用start()开启线程
• 注意：
  • 线程开启不一定立即执行，由CPU调度执行

//创建线程方式一：继承Thread ，重新run(),调用start()开启线程
public class Demo01  extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("方式一创建线程的run方法"+i);
        }
    }
    public static void main(String[] args) {
        //创建线程对象
        Demo01 thread=new Demo01();
        //调用start（）开启线程
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("方式一创建线程的Main方法"+i);
        }
    }
}
缺点：OOP单继承局限性，不推荐使用

方式二

• 创建类实现Runnable接口
• 实现run()方法，编写线程执行体
• 创建线程对象，调用start()开启线程
• 优点：避免OOP单继承局限性，灵活方便，方便同一个对象被多线程使用，推荐

//方式二
public class Demo02 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("方式二创建线程的run方法"+i);
        }
    }
    public static void main(String[] args) {
        //创建Runnable 接口的实现类
        Demo02 demo02=new Demo02();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread=new Thread(demo02);
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("方式二创建线程的Main方法"+i);
        }
    }
}

线程的运行由调度器安排调度

方式三

• 实现Callable()接口，需要返回值类型
• 重新call方法，需要抛出异常
• 创建目标对象
• 创建执行服务： ExecutorService service= Executors.newFixedThreadPool(3);
• 提交执行： Future result1=service.submit(demo06);
• 获取结果: Object resultset1 = result1.get();
• 关闭服务:service.shutdown();
• 好处：
  - 可以定义返回值
  - 可以抛出异常

public class Demo06 implements Callable<Object> {
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return Thread.currentThread().getName();
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建目标对象
        Demo06 demo06=new Demo06();
        //创建执行服务
        ExecutorService service= Executors.newFixedThreadPool(3);
        //提交执行
        Future<Object> result1=service.submit(demo06);
        Future<Object> result2=service.submit(demo06);
        Future<Object> result3=service.submit(demo06);
        // 获取结果
        Object resultset1 = result1.get();
        Object resultset2 = result2.get();
        Object resultset3 = result3.get();
        System.out.println(resultset1);//pool-1-thread-1
        System.out.println(resultset2);//pool-1-thread-2
        System.out.println(resultset3);//pool-1-thread-3
        service.shutdown();//关闭服务
    }
}

初识并发问题

//多线程同时操作一个对象
//购买火车票
//问题：多个线程同时操作同一个资源的情况下，线程不安全，数据紊乱
public class Demo04 implements Runnable {
    private int ticketNum=10;
    @Override
    public void run() {
        while (ticketNum>0){
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNum+"张票");
            ticketNum--;
            //模拟延迟
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Demo04 ticket = new Demo04();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小红").start();
        new Thread(ticket,"小花").start();
    }
}