Java多线程,线程的生命周期,线程的创建方式,线程安全。-蒲公英云

1.进程和线程

进程与线程的定义

进程:

是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元,系统会为这个进程发配独立的内存资源。
例如：正在运行的 QQ、IDE、浏览器就是进程

线程:

具体执行任务的最小单位 .就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。

进程与线程的联系

序号	进程与线程的联系
（1）	一个进程最少拥有一个线程—主线程—- 运行起来就执行的线程
（2）	线程之间是共享内存资源的（这个内存资源是由进程申请的）
（3）	线程之间可以通信（进行数据传递：多数为主线程和子线程）
（4）	每一个线程都有自己的运行回路

2.线程的生命周期

线程的生命周期	定义
新建(`NEW` )	线程刚被创建好，从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态
就绪 (`RUNNABLE`）	线程对象调用`start()`方法后，就处于就绪状态，等到JVM里的线程调度器的调度，只要抢到时间片就可以运行这个线程
运行（`RUNNING`）	就绪状态下的线程在获取CPU资源后就可以执行`run()`,此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态
等待/阻塞/睡眠（`BLOCKED`）	在一个线程执行了`sleep`（睡眠）、`wait`(等待）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态
终止(`TERMINATED`)	run（）方法完成后或发生其他终止条件时就会切换到终止状态

图例：

3.创建子线程的原因

如果在主线程中存在有比较耗时的操作（例如：下载视频、上传文件数据处理）
这些操作会阻塞主线程，后面的任务必须等这些任务执行完毕之后才能执行，用户体验比较差，为了不阻塞主线程，需要将耗时的任务放在子线程去处理

4.创建线程的方法

创建线程的第一种方法—-继承Thread类实现run方法

步骤：

① 定义类继承Thread;
② 复写Thread类中的run方法；（目的：将自定义代码存储在run方法，让线程运行）

③调用线程的start方法：(该方法有两步：启动线程，调用run方法)

public class Myclass {
    public static void main(String[] args){
        // main方法里面执性的代码 是在主线程里面执行的
        String name=Thread.currentThread().getName();//创建一个对象，获取当前线程的名称赋给该对象
        System.out.println(name);//打印线程的名称
       //创建第一个线程
        TestThread tt=new TestThread(); //创建Thread的对象
        tt.setName("子线程1"); //设置线程的名称
        tt.start();// //开启任务
        //创建第二个线程
        TestThread tt2=new TestThread();
        tt2.setName("子线程2");
        tt2.start();
    }
}
// 定义一个类继承Thread
class TestThread extends Thread{
    //复写Thread类中的run方法，方法里面具体需要执行的代码
    @Override
    public void run() {
        String name=Thread.currentThread().getName();//创建了一个对象，获取了线程的名字赋给name
        for(int i=0;i<100;i++){
            System.out.println(name+":"+(i+1));
  }
        super.run();
    }
}

试思考：**tt.start();**

        TestThread tt=new TestThread(); //创建Thread的对象
        tt.setName("子线程1"); //设置线程的名称
        tt.start();// //开启任务
        tt.start();

回答：会出错，因为：对同一个线程不能同时开启

进阶小demo：

将上诉demo进行完善，实现当子线程1执行到10后，子线程1就被阻塞，然后开始执行线程2直至线程2结束，即线程2执行到100，然后才执行线程1

public class Myclass {
 static TestThread tt2;
  public static void main(String[] args) {
//        main方法里面执性的代码 是在主线程里面执行的
      String name = Thread.currentThread().getName();
      System.out.println(name);
      //创建Thread的对象
      TestThread tt = new TestThread();
      //设置线程的名称
      tt.setName("子线程1");
      //开启任务
      tt.start();//只有这一句话耽误了一点时间
      tt2 = new TestThread();
      //设置线程的名称
      tt2.setName("子线程2");
      //开启任务
      tt2.start();
}
}
    class TestThread extends Thread {
  //实现run方法
  //方法里面具体需要执行的代码
  @Override
  public void run() {
      String name = Thread.currentThread().getName();//创建了一个对象，获取了线程的名字赋给name
//        System.out.println(name);
      for (int i = 1; i < 101; i++) {
          System.out.println(name + ":" + (i ));
          if (this != Myclass.tt2) {//判断是否是子线程1
              if (i == 10) {
                  try {
                      Myclass.tt2.join();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
      super.run();
  }
}

上面一段demo中所用到的方法如下：

方法	作用
`join()`	让当前这个线程阻塞等join()的线程执行完毕再执行
`setName()`	设置线程名称
`getName()`	获取线程名称
`currentTHread()`	获取当前运行的线程对象

创建线程的第二种方式：实现Runnable接口

注意事项：接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。

步骤：
① 创建任务：创建类实现Runnable接口
② 使用Thread 为这个任务分配线程
③ 开启任务Start()

使用方式1—-创建一个类实现Runnable接口，使用Thread来操作这个任务

public class Myclass {
    public static void main(String[] args) {
    PXDThread pt=new PXDThread();//创建类的对象
        //使用Thread操作这个任务
        Thread t=new Thread(pt);
         t.setName("子线程1");
         t.start();
        Thread t2=new Thread(pt);
        t2.setName("子线程2");
        t2.start();
  }
}
class PXDThread implements Runnable{//创建了一个PXDThread类并实现Runnable接口
    public void run() {
        for(int i=0;i<=100;i++) {
            System.out.println(Thread.currentThread().getName()+" :"+i);
        }
    }
}

（在main函数里）
使用方式2—-这个任务只需要使用一次

public class Myclass {
    public static void main(String[] args) {
         Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<=100;i++) {
                    System.out.println(Thread.currentThread().getName()+": "+i);
                }
            }
        });
        t.setName("子线程1");
        t.start();
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<=100;i++) {
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        });
        t2.setName("子线程2");
        t2.start();
  }
}

使用方式3—-创建线程的同时直接开启线程任务，不需操作线程对象本身

    new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<=100;i++) {
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        }).start();

**使用方式4—使用Lammbda表达式（不建议：阅读性太差）

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

5.线程安全

多个线程操作同一个资源，线程无法确定自己什么时候被阻塞，容易导致数据错误

要编写线程安全的代码，其核心在于要对状态访问操作进行管理，特别是对共享的和可变的状态的访问。一个对象是否需要是线程安全的，取决于它是否被多个线程访问。要使得对象是线程安全的，需要采用同步机制来协同对象可变状态的访问。当多个线程访问某个状态变量并且其中一个线程执行写入操作时，必须采用同步机制来协同这些线程对变量的访问。

同步代码块的两种方式

我们以卖火车票为例：

首先：我们来看一个小例子：

public class Myclass {
    public static void main(String[] args) {
       Ticket ticket=new Ticket("重庆");
         Thread t1=new Thread(ticket);
         t1.start();
         Ticket ticket1=new Ticket("上海");
         Thread t2=new Thread(ticket1);
         t2.start();
   }
}
//用于买票的任务(共享-》静态）
class Ticket implements  Runnable {
    //定义所有车票的数量
    public static int num = 100;
    String name;
    public Ticket(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
           System.out.println(name + "出票：" +i);
                }
            }
       }

得到的结果是：上海出票100，重庆出票100，并没有达到重庆和上海共用100票的目的

同步代码块的第一种方式—-synchronized（参数就是一个监听器）

synchronized(监听器/对象/对象的一把锁）{
              //需要同步的代码
}

public class Myclass {
    public static void main(String[] args) {
       Ticket ticket=new Ticket("重庆");
         Thread t1=new Thread(ticket);
         t1.start();
         Ticket ticket1=new Ticket("上海");
         Thread t2=new Thread(ticket1);
         t2.start();
   }
}
class Ticket implements  Runnable {
    //定义所有车票的数量
    public static int num = 100;
    String name;
    public Ticket(String name) {
        this.name = name;
    }
    static  final  Object obj = new Object();
  @Override
       public void run() {
        for (int i = 0; i <= 100; i++) {
            synchronized (obj) {
                if (num > 0) {
                    System.out.println(name + "出票：" + num);
                    num--;
                    try {
                        //当前线程等待
                        obj.notify();
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        //通知其他线程执行
                    }
                } else {
                    break;
                }
            }
        }
    }
}

同步代码块的第二种方式—-ReentrantLock

public class Myclass {
    public static void main(String[] args) {
       Ticket ticket=new Ticket("重庆");
         Thread t1=new Thread(ticket);
         t1.start();
         Ticket ticket1=new Ticket("上海");
         Thread t2=new Thread(ticket1);
         t2.start();
   }
}
class Ticket implements  Runnable {
    //定义所有车票的数量
    public static int num = 100;
    String name;
    public Ticket(String name) {
        this.name = name;
    }
    static ReentrantLock lock=new ReentrantLock();
 @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
           lock. lock();//加锁
                if (num > 0) {
                    System.out.println(name + "出票：" + num);
                    num--;
                } else {
                    break;
                }
                lock.unlock();//解锁
            }
        }
    }

6.线程入门小demo

public class Person implements Agent.AgentInterface {//实现了Agent.AgentInterface接口
    public void needHouse(){
        Agent xw=new Agent();
        xw.target=this;//表明吧对象返回给谁
        xw.start();
    }
    @Override
    public void callBack(String desc) {
        System.out.println("我是小王，接收到你的数据了："+desc);
    }
}

//1.继承Thread,重写run方法
public class Agent extends Thread{
    AgentInterface target;
    @Override
    public void run() {
        System.out.println(Thread.currentThread());
        System.out.println("开始找房子");
        System.out.println("----------");
        System.out.println("房子找到了");
        target.callBack("房子在西南大学");
        super.run();
    }
    public interface AgentInterface{
        void callBack(String desc);//把找到的房源信息返回
    }
}

public class Myclass {
    public static void main(String[] args) {
            Person zs = new Person();
            zs.needHouse();
    }
}

1.进程和线程

进程与线程的定义

进程:

线 程:

进程与线程的联系

2.线程的生命周期

3.创建子线程的原因

4.创建线程的方法

创建线程的第一种方法—-继承Thread类实现run方法

进阶小demo：

创建线程的第二种方式：实现Runnable接口

5.线程安全

同步代码块的两种方式

同步代码块的第一种方式—-synchronized（参数就是一个监听器）

同步代码块的第二种方式—-ReentrantLock

6.线程入门小demo

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

随便看看

教程文章

热评文章

1江湖小白之一起学Python （二）爬取数据的保存

2Java Shiro：简化身份验证和授权的安全框架

3Java中try()catch{}的使用方法

4Swagger注解-@ApiModel 和 @ApiModelProperty

5windows下强制杀死tomcat进程

6uni-app 条形码(一维码)/二维码生成实现

标签列表

线程: