线程的基础学习（一）

基本概念

• 进程：一个正在运行的应用程序

• 线程：执行代码的最小单元，应用的具体功能都是由线程来完成

            一个进程可以包含多个线程（一个进程至少包含一条线程）

• 主线程：程序启动时，第一条线程，执行入口函数(main)

• 子线程：非主线程的其它线程

• 守护线程：为其他线程提供辅助，被守护线程终止，对应的守护吸线程也会立即终止

• 同步：多个操作指令，一个指令执行完毕，才能执行下一个指令

• 异步：多个操作指令，一个指令执行时，不用等待执行结果，就可以执行下一个指令(多个指令同时执行)

• 并发：伪并行，CPU在多个线程之间加速的切换，感觉是是多个线程同时执行，本质上同一个时刻只能执行一条线程

• 并行：同一个时刻，多个线程同时执行

线程的六种基本状态

1、新建状态(New)：

当线程对象被创建时，处于新建状态，此时线程尚未启动，还没有分配到系统资源

2、就绪状态(Runnable):

线程调用start()方法后进入就绪状态，说明线程做好了准备，随时等待CPU调度执行

3、运行状态(Running)：

当CPU开始调度处于就绪状态的线程，线程才进入运行状态

4、阻塞状态(Blocked):

线程在执行过程中，可能由于某些原因被阻塞

例如：线程等待某个锁的释放或者等待某个输入/输出操作完成，当满足特定条件时，阻塞状态可进入可运行状态

5、等待状态(Waiting):

线程等待某个条件满足时进入等待状态

6、死亡状态(Dead):

线程执行完毕或者因为异常退出了run()方法，该线程结束生命周期

线程的基本方法

public static void main1( String[] args )
    {
        //获取当前线程
        Thread thread=Thread.currentThread();
        System.out.println(thread);
        //获取线程名称
        String name=thread.getName();
        System.out.println("name= "+name);
        //获取优先级
        int priority=thread.getPriority();
        System.out.println("priority="+priority);
        //获取线程所在的分组
        ThreadGroup threadGroup=thread.getThreadGroup();
        System.out.println("threadGroup="+threadGroup);
        //线程ID
        long id=thread.getId();
        System.out.println("id="+id);
    }

实现多线程的方式

• 继承Thread，重写run()方法

    Thread thread=new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread());
            }
        };   };
        //直接调用run方法，在哪个线程中调用，run方法就由该线程执行
        thread.run();
        //线程就是进入了就绪状态，本质就是告知CPU，该线程已经初始化完毕，随时可调用
        thread.start();
        Thread.sleep(2000);
//        thread.setName("abc");

• 实现Runnable，重写run()方法

      Runnable runnable =new Runnable() {
            @Override
            public void run() {
                //this：任务对象
                System.out.println(this);
                //执行该任务的线程对象
                System.out.println(Thread.currentThread());
            }
        };
      new Thread(runnable).start();

• 实现Callable对象，交给线程执行

//callable任务不能直接交给Thread执行，Thread只能执行Runnable任务
        Callable<String> callable=new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "返回值";
            }
        };
        //实现了Runnable和Future接口，Runnable：让Thread能执行
        //Future：是为了接收返回值
        FutureTask<String> task=new FutureTask<>(callable);
        new Thread(task).start();
        //获取返回值，get是一个阻塞式的方式
//        String result= task.get();
//        System.out.println("result"+result);
        //设置超时时间，当超出该时间还获取不到返回值，该方法就会立即抛出中断异常
        String result=task.get(5, TimeUnit.MINUTES);

总的来说，Thread是直接创建线程的方式，Runnable是将任务逻辑封装为一个可执行的对象，不是一个真正的线程，而Callable则是具有返回值的任务。使用Runnable和Callable可以更灵活地管理线程，避免了类的单继承限制，并且可以获取任务的执行结果。