JAVA入门————多线程创建 AND 更改名称 AND 线程状态

线程

进程:是系统进行资源分配和调用的独立单位

每个进程都有属于自己的内存资源和系统空间

线程:是CPU执行和调度的基本单位
  • 一个进程内部执行多个任务 每个任务为一个线程 一个进程包含一个或多个线程

多线程

  • 同一个时间段可以执行多个任务 ————eg:边打游戏边听歌
    打游戏和听歌不是同时进行,他们在CPU里来回切换执行 计算机速度很快 我们无法察觉
  • 一个时间点 一个CPU只能执行一段代码 因为速度很快 所以有同时执行的错觉
  • 优点:提高CPU使用率

解释:程序在运行过程中 线程的运行是由调度器安排调度的——是在抢CPU的时间片,也就是执行权,抢到了时间才能运行
多线程抢到几率比单线程抢到的几率大的多 CPU在多线程中执行的时间比单线程的多 所以提高了程序的使用率
至于多线程中哪个线程能够抢到执行权不确定 所以多线程具有随机性

并行:某一时间内同时运行多个程序——真正的同时
并发:某一时间点同时运行多个程序——来回切换 有同时的错觉

问题:JVM的启动时多线程吗?
——————是的,至少启动了main()的主线程和垃圾回收线程
main( ) :主线程,系统的入口 执行整个程序

线程的创建

JVM虚拟机调用run( ) 方法
run( )中封装的代码是线程必须执行的代码 一般为耗时较长的代码

继承Thread类

  1. 实现Thread类
  2. 重写run( )方法
  3. 实例化类——创建类对象
  4. 调用start( ) 方法————————启动线程
public class demo extends Thread{
     
    @Override
    public void run() {
     ——————————重写run方法
        for (int i = 0; i < 10; i++) {
     
            System.out.println("这是线程   "+i);
        }
    }
    public static void main(String[] args) {
     
      demo demo = new demo();————————实例化对象
      demo.start();
    }
}

实现Runnable接口————推荐使用

优点:避免单继承的局限性 方便一个对象被多个线程使用

  1. 实现Runnable接口
  2. 重写run( )方法
  3. 实例化实际类
  4. 实例化Thread代理类 传入类对象
  5. 调用start( )方法
public class demo implements Runnable {
     
    @Override
    public void run() {
     
        for (int i = 0; i < 10; i++) {
     
            System.out.println("hello Runnable! "+i);
        }
    }
    public static void main(String[] args) {
     
        demo demo = new demo();
        Thread thread = new Thread(demo);
        thread.start();
    }
}
实现Callable接口

Thread方法

public static Thread currentThread()——获取当前执行的线程
public final String getName()——获取线程名称
public final void setName(String name)——设置线程名称
  • Runnable更改线程名称方法 一:
public class RunnableName1 implements Runnable{
     
    @Override
    public void run() {
     
        for (int i = 0; i < 5; i++) {
     
            System.out.println("子线程名称: "+Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) {
     
        RunnableName1 runnableName1 = new RunnableName1();
        Thread thread = new Thread(runnableName1,"我是子");  ——————  设置子线程名称
        thread.start();
        Thread.currentThread().setName("我是主——");  ————设置主线程名称
        for (int i = 0; i < 3; i++) {
     
            System.out.println("主线程名称: "+Thread.currentThread().getName());
        }   -————————输出:主线程名称: 我是主—— x3  子线程名称: 我是子 x5
    }
}
  • 更改线程名称方法二:
  thread.setName("我是子线程1");
  • Thread更改线程名称方法一:
public class Threadname extends Thread {
     
    public Threadname(String name){
     
        super(name);
    }
    @Override
    public void run() {
     
        for (int i = 0; i < 4; i++) {
     
            System.out.println("子线程名称——"+Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) {
     
        Threadname threadname = new Threadname("我是子线程呀");——————直接更改
        threadname.start();

        Thread.currentThread().setName("主线程!");
        for (int i = 0; i < 2; i++) {
     
            System.out.println("主线程名称—"+Thread.currentThread().getName());
        }
    }
}
  • 更改线程名称方法二:
 eg:	Threadname threadname = new Threadname();
        threadname.setName("我是子线程呀!");

线程的状态

  • 创建状态:线程一旦创建 就进入了新生状态
  • 就绪状态:线程调用start( )方法后的状态 但不一定立即调度执行
  • 运行状态:线程抢到了CPU资源后的状态 执行线程体的代码块
  • 死亡状态:线程自然执行结束 终止线程 不能再次启动
  • 阻塞状态:当调用sleep( ) wait( ) 同步锁定时的状态 代码不往下执行 阻塞解除后 重新进入就绪状态 等待CPU调度执行
public final int getPriority() ——获取线程的优先级 范围:1(min)----10(max)
public final void setPriority(int newPriority)——设置线程的优先级
public final int getPriority()———返回线程的优先级(默认为5)

设置优先级只能使其被CPU分配调度的概率增大 因为多线程具有随机性

public class Threadyouxianji implements Runnable {
     
    @Override
    public void run() {
     
        for (int i = 0; i < 5; i++) {
     
            System.out.println("线程名称: "+Thread.currentThread().getName()+"--线程优先级: "+Thread.currentThread().getPriority()+"====循环次数——"+i);
        }
    }
    public static void main(String[] args) {
     
        Threadyouxianji threadyouxianji = new Threadyouxianji();
        Thread thread = new Thread(threadyouxianji,"子线程1");
        thread.setPriority(Thread.MIN_PRIORITY);
         System.out.println(thread.getPriority());——————默认为5
        thread.start();
        Thread thread2 = new Thread(threadyouxianji, "子线程2222");
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread2.start();
    }
}

public static void sleep(long millis)——线程休眠

public class Threadsleep implements Runnable {
     
    @Override
    public void run() {
     
        String[] pome = {
     "时间一直倒数着","我们许下的快乐" ,"此刻相拥的狂热" ,"却永远都深刻"};
        for (int i = 0; i < pome.length; i++) {
     
            System.out.println(pome[i]);
            try {
     
                Thread.sleep(1000);———————每一句使线程休眠1} catch (InterruptedException e) {
     
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
     
        Threadsleep threadsleep = new Threadsleep();
        Thread thread = new Thread(threadsleep);
        thread.start();
    }
}

public final void join()——线程加入

  • 此线程必须执行结束之后 其他线程才能继续执行
public class Threadjoin implements Runnable{
     
    private static boolean b = true;
    @Override
    public void run() {
     
        for (int i = 0; i < 10; i++) {
     
            System.out.println("子线程名称 " +Thread.currentThread().getName()+ "; "+ i);
        }
    }
    public static void main(String[] args) {
     
        Threadjoin threadjoin = new Threadjoin();
        Thread thread = new Thread(threadjoin,"子线程1号");
        thread.start();
        Thread.currentThread().setName("我是主线程main");

        for (int j = 0; j < 10; j++) {
     
            if(j == 5){
     
                try {
     
                    thread.join();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
            System.out.println("主线程名称——"+Thread.currentThread().getName()+ "===="+j);
        }
    }————-输出:.....
    		   主线程名称——我是主线程main====4 ——————当主线程j = 4时  执行子线程
			   子线程名称 子线程1; 0     ————————-子线程执行结束后  继续运行主线程
}

public static void yield()——线程礼让

  • 暂停当前正在执行的线程对象 并执行其他线程
  • 效果不明显——暂停时间过短 其他线程还没有来得及执行就又被此线程抢走了CPU执行权
public class Threadyield implements Runnable{
     
    @Override
    public void run() {
     
        System.out.println(Thread.currentThread().getName()+"线程开始了");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束了");
    }
    public static void main(String[] args) {
     
        Threadyield threadyield = new Threadyield();
        Thread thread = new Thread(threadyield,"线程1");
        Thread thread2 = new Thread(threadyield, "线程2");
        thread.start();
        thread2.start();
    } ——————————————输出:线程2线程开始了
						 线程1线程开始了
						 线程1线程结束了
						 线程2线程结束了
}

public final void setDaemon(boolean on)——线程守护

  • 用户线程:系统的工作线程 用于计算等
  • 守护线程:辅助用户线程 eg:内存管理 垃圾回收站
  • 步骤
  1. 创建用户线程类
  2. 创建守护线程类
  3. 实例化守护线程类————创建守护对象
  4. thread.setDaemon( true) ————设置线程为守护线程————在调用start( )之前
  5. 实例化用户线程类————创建用户对象
  • 当用户线程结束 运行的线程都是守护线程时 虚拟机退出——在启动线程之前调用
public class ThreadDaemon{
     
    public static void main(String[] args) {
     
        ——————————  实例化守护线程
        Daemon daemon = new Daemon();
        Thread thread = new Thread(daemon);
        thread.setDaemon(true);
        thread.start();
        —————————— 实例化用户线程
        User user = new User();
        Thread thread1 = new Thread(user);
        thread1.start();
    }
}
class User implements Runnable{
        // 用户线程
    @Override
    public void run() {
     
        for (int i = 0; i < 10; i++) {
     
            System.out.println(Thread.currentThread().getName()+"我是用户线程!  "+i);
        }
    }
}
class Daemon implements Runnable{
         //  守护线程
    @Override
    public void run() {
     
        int i = 0;
      while(true){
     
          System.out.println(Thread.currentThread().getName()+"守护线程守护你-----"+i);
      }   ————————————————输出:守护线程开始  用户线程  守护线程结束
    }
}

已过时:public final void stop()——强行停止线程的运行

  • 停止一个尚未启动的线程是允许的。如果最后启动了该线程,它会立即终止。

public void interrupt()——中断线程

  • 可得当线程调用wait(),sleep(long time)方法的时候处于阻塞状态,这个方法可以清除阻塞
public class ThreadStop implements Runnable {
     
    private static boolean flag = true;   //  自定义线程停止标志
    @Override
    public void run() {
     
        int i = 0;
        while(flag){
     
            System.out.println("我是子线程——————"+ i++);
        }
    }
    public static void main(String[] args) {
     
        ThreadStop threadStop = new ThreadStop();
        Thread thread = new Thread(threadStop);
        thread.start();

        for (int i = 0; i < 10; i++) {
     
            System.out.println(Thread.currentThread().getName()+ i);
            if(i==5){
     
                ThreadStop.flag = false;
            }
        }
    }
}

龟兔赛跑

public class RaceTest implements Runnable {
     
    private static  String Winner = null;
    @Override
    public void run() {
     
        for (int m = 0; m < 120; m++) {
     
            boolean flag = GameOver(m);
            try {
     
                Thread.sleep(500);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            if("兔子".equals(Thread.currentThread().getName())  &&  m % 30 ==0 ) {
     
                try {
     
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
                System.out.println(Thread.currentThread().getName()+"跑了"+m+"米");
                if(flag){
     
                    break;
                }
        }
    }
    private boolean GameOver(int meters) {
        // 判断比赛结束条件
        if (meters == 101) {
     
            Winner = Thread.currentThread().getName();
            System.out.println("胜利者是——" + Winner);
            return true;
        }
        if (Winner != null){
        //  如果已分出胜负 不用再继续比赛
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
     
        RaceTest raceTest = new RaceTest();
        Thread 兔子 = new Thread(raceTest, "兔子");
        Thread 乌龟 = new Thread(raceTest, "乌龟");
        兔子.start();
        乌龟.start();
    }
}

你可能感兴趣的:(多线程,多进程,java,javase)