java多线程学习(一)：线程概念、线程创建方式、线程状态、线程方法

多线程学习

一、线程简介

1.基本概念

程序：程序是指令和数据的有序集合，其本身没有任何运行含义，是一个静态的概念

进程：是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位

通常一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换很快，所以有同时执行的错觉。

2.核心概念

• 线程就是独立执行的路径；
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
• main()称之为主线程，为系统的入口，用于执行整个程序；
• 在一个进程中，如果开辟了多个线程，线程运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的；
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
• 线程会带来额外的开销，如cpu调度时间，并发控制开销；
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致；

二、线程创建

1.继承Thread类

• 自定义线程继承Thread类
• 重写run方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程

代码测试：

//创建线程方式一：继承Thread类，重写run方法，调用start开始线程
//总结：注意，线程开启不一定立即执行，由cpu调度执行
public class TestThread01 extends Thread{
    @Override
    public void run(){
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码--"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread01 testThread01 = new TestThread01();
        //调用start()方法
        testThread01.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

输出1：

我在看代码--0
我在看代码--1
我在看代码--2
我在看代码--3
我在学习多线程--0
我在看代码--4
我在学习多线程--1
我在看代码--5
我在学习多线程--2
我在看代码--6
我在看代码--7
我在看代码--8
我在看代码--9
我在看代码--10
我在学习多线程--3
我在看代码--11
我在看代码--12
我在看代码--13
我在看代码--14
我在看代码--15
我在看代码--16
我在看代码--17
我在学习多线程--4
我在看代码--18
我在看代码--19
我在学习多线程--5
我在学习多线程--6
我在学习多线程--7
我在学习多线程--8
我在学习多线程--9
我在学习多线程--10
我在学习多线程--11
我在学习多线程--12
我在学习多线程--13
我在学习多线程--14
我在学习多线程--15
我在学习多线程--16
我在学习多线程--17
我在学习多线程--18
我在学习多线程--19

输出2：

我在学习多线程--0
我在看代码--0
我在学习多线程--1
我在学习多线程--2
我在看代码--1
我在学习多线程--3
我在看代码--2
我在学习多线程--4
我在学习多线程--5
我在看代码--3
我在看代码--4
我在看代码--5
我在看代码--6
我在学习多线程--6
我在学习多线程--7
我在学习多线程--8
我在学习多线程--9
我在学习多线程--10
我在学习多线程--11
我在学习多线程--12
我在学习多线程--13
我在学习多线程--14
我在学习多线程--15
我在学习多线程--16
我在学习多线程--17
我在看代码--7
我在学习多线程--18
我在看代码--8
我在看代码--9
我在看代码--10
我在看代码--11
我在看代码--12
我在看代码--13
我在看代码--14
我在看代码--15
我在看代码--16
我在看代码--17
我在看代码--18
我在看代码--19
我在学习多线程--19

交替运行。

2.实现Runnable接口

• 自定义MyRunnable类实现Runnable接口
• 实现run()方法，编写线程执行体
• 创建线程对象，调用start方法启动线程

测试：

//创建线程方式二：实现runable接口，重写run方法，执行线程需要丢人runnable接口实现类，调用start()方法
public class TestThread02 implements Runnable{
    @Override
    public void run(){
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码--"+i);
        }
    }
    public static void main(String[] args) {
        //main线程，主线程
        //创建runnable接口实现类
        TestThread02 testThread02 = new TestThread02();
        //创建线程对象，通过线程对象来开启我们的线程
        Thread thread = new Thread(testThread02);
        //调用start()方法
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

效果和方式一一样

3.继承Thread类与实现Runnable接口总结

• 继承Thread类

  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用：避免OOP单继承局限性

• 实现Runnable接口

  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start()
  • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

  多个线程同时操作一个对象演示：

  //多个线程同时操作同一个对象
  public class TestThread03 implements Runnable {
      //票数
      int ticketNums = 10;
      @Override
      public void run() {
          while (true){
              if(ticketNums<=0)
                  break;
                  System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
          }
      }
      public static void main(String[] args) {
          TestThread03 ticket = new TestThread03();
          new Thread(ticket,"何大春").start();
          new Thread(ticket,"何中春").start();
          new Thread(ticket,"何小春").start();
      }
  }
  

  输出：

  何大春-->拿到了第10票
  何大春-->拿到了第7票
  何大春-->拿到了第6票
  何大春-->拿到了第5票
  何小春-->拿到了第8票
  何中春-->拿到了第9票
  何小春-->拿到了第3票
  何小春-->拿到了第1票
  何大春-->拿到了第4票
  何中春-->拿到了第2票
  

  以上情况会造成数据紊乱，也就是并发问题，具体后面在了解。

4.实现Callable接口

• 实现callable接口，需要返回值类型
• 重写call方法，需要抛出异常
• 创建目标对象
• 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
• 提交执行：Future result1.get()
• 获取结果：boolean r1 = result1.get()
• 关闭服务：ser.shutdownNow();

简单实现：

//线程创建方式三：实现Callabe接口
/*
Callable的好处
1.可以定义返回值
2.可以抛出异常
 */
public class TestThread04 implements Callable {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码--"+i);
        }
        return true;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        TestThread04 testThread04 = new TestThread04();
        //创建执行服务：
        ExecutorService ser = Executors.newFixedThreadPool(1);
        //提交执行：
        Future<Boolean> r1 = ser.submit(testThread04);
        //获取结果：
        boolean rs1 = r1.get();
        //关闭服务：
        ser.shutdownNow();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--"+i);
        }
        System.out.println(rs1);
    }
}

三、线程状态

1.线程5个状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cVQ90DRg-1628945917773)(E:\maven\study\多线程\线程状态.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jzQHGzkr-1628945917774)(E:\maven\study\多线程\线程状态详细.png)]

2.线程方法

方法	说明
setPrioity(int newPrioity)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程体休眠
void join()	等待该线程终止
static void yield()	等待当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程，别用这个方式
boolean isAlive	测试线程是否处于活动状态

1）停止线程

• 不推荐使用JDK提供的stop()、destroy()方法。「已废弃」
• 推荐线程自己停止下来
• 推荐使用一个标志位进行终止变量，当flag=false，则终止线程运行。

public class TestStop implements Runnable{
    //1.线程中定义线程体使用标识
    private boolean flag = true;
    @Override
    public void run(){
        //2.线程体使用该标识
        while(flag){
            System.out.println("run...Thread");
        }
    }
    //3.对外提供改变标识
    public void stop(){
        this.flag = false;
    }
}

2）线程休眠

• sleep(时间)指定当前线程阻塞的毫秒数；
• sleep存在异常InterruptedException；
• sleep时间达到后线程进入就绪状态
• sleep可以模拟网络延时，倒计时等；
• 每一个对象都有一个锁，sleep不会释放锁

3）线程礼让

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转变为就绪状态
• 让cpu重新调度，礼让不一定成功！看cpu心情

//测试礼让线程
//礼让不一定成功，看CPU心情
public class TestYield {
    public static void main(String[] args) {
        Myyield myyield = new Myyield();
        new Thread(myyield,"a").start();
        new Thread(myyield,"b").start();
    }

}
class Myyield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

a线程开始执行
b线程开始执行
a线程停止执行
b线程停止执行

礼让成功案例，每次执行结果不同，礼让不一定成功，只是让cpu重新调度。

4）Join方法

• Join合并线程，待此线程执行完成后，再执行其他程序，其他程序阻塞
• 可以想象成插队

//测试jion方法
//想象为插队
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        //主线程
        for (int i = 0; i < 500; i++) {
            if (i==200){		//当i==200时，开始执行thread线程，使用了join方法main线程进入阻塞状态直到thread执行完
                thread.start();
                thread.join();//插队 main线程阻塞
            }
            System.out.println("main"+i);
        }
    }
}

5）线程状态观测

Thread.State

线程状态。线程可处于以下状态之一：

• NEW

尚未启动的线程状态

• RUNNABLE

在java虚拟机中执行的线程处于此状态

• BLOCKED

被阻塞的等待监视器锁定的线程处于此状态

• TIMED_WAITING

正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

• TERMINATED

已退出的线程处于此状态