多线程

xiaozhangStu

发布于 2023-05-04 19:29:39

2540

发布于 2023-05-04 19:29:39

文章被收录于专栏：xiaozhangStuxiaozhangStu

多线程

进程

定义

应用程序的执行实例（最小单位）

有独立的内存空间与系统资源

线程

定义

包含在进程里面

CPU调度与分派的基本单位

执行运算的最小单位，可以完成独立的顺序流程的控制

多线程定义

一个进程当中同时运行了多个线程，用来完成不同的工作，这就叫做多线程

优点

1.充分利用CPU的资源

2.简化编程模型

3.带来良好的用户体验

主线程

main()方法就是主线程的入口

产生请其他子线程的线程

必须最后完成，因为他要执行各种的关闭动作

使用线程步骤

1.定义线程

2.创建线程对象

3.启动线程

4.终止线程

创建线程的两种方式

继承Thread类

1.定义MyThread类继承Thread类

2.重写run方法，编写线程执行体

3.创建线程对象，调用start()方法开启线程

举例

public class MyThread extends Thread{
    //重写run()方法
    public void run(){
        for(int i=1;i<100;i++){         System.out.println(
        Thread.currentThread().getName()+":"+i);
}
    }
}

public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); //启动线程}

}

实现Runnable接口

1.定义MyRunnable类实现Runnable的接口

2.实现run方法，编写线程执行体

3.创建线程对象，调用start()方法启动线程

举例

public class MyRunnable implements Runnable{
    public void run(){
        for(int i=1;i<100;i++){         System.out.println(
        Thread.currentThread().getName()+":"+i);
}
    }
}


public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread myThread = new Thread(myRunnable);   
        myThread.start(); //启动线程}
}

使用线程的注意点

1.多线程交替执行，并不是一起执行，总有先后但是实践很短，看不出来

2.每次线程执行的时长是由分配的CPU时间片长度决定的

3.开启线程不能用run（）方法，用run（）只是调用搞线程类的方法，并不是开启线程

线程的状态

1.创建状态

2.就绪状态

3.阻塞状态

4.运行状态

5.死亡状态

线程调度的相应方法

//setPriority(int  newPriority)--->设置线程的优先级
public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread(),"线程A");
        Thread t2 = new Thread(new MyThread(),"线程B");
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
       //省略代码……
    }}



//static void sleep(long millis)--->在指定的毫秒数内让当前正在执行的线程休眠
public class Wait {
    public static void bySec(long s) {
        for (int i = 0; i < s; i++) {
            System.out.println(i + 1 + "秒");
            try {
                Thread.sleep(1000); 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//void join()--->等待该线程终止
public static void main(String[] args) {
        Thread temp = new Thread(new MyThread());
        temp.start();
        for(int i=0;i<20;i++){
            if(i==5){               
                try {
                    temp.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                     }
              }         
System.out.println(Thread.currentThread().getName()+"运行："+i);
      }
       //省略代码……
}


//static void yield()--->暂停当前正在执行的线程对象，并执行其他线程(不一定会礼让)
public class MyThread implements Runnable{
     public void run(){
         for(int i=0;i<5;i++){
             System.out.println(Thread.currentThread().
              getName()+"正在运行："+i);
             if(i==3){
                System.out.print("线程礼让：");
                Thread.yield();  
             }
         }
     }
}


//void interrupt()--->中断线程

//boolean isAlive()--->测试线程是否处于活动状态

synchronized关键字

作用

用来解决多个线程操作同一共享资源时，将引发的数据不安全的问题（为当前的线程声明一个锁，该类资源等待该线程做完之后其他线程才能访问）

使用方式

访问修饰符 synchronized 返回类型 方法名（参数列表）{……}
        或者
synchronized 访问修饰符 返回类型 方法名（参数列表）{……}
        或者
synchronized(syncObject){
    //需要同步的代码
    //syncObject为需同步的对象，通常为this
    //效果与同步方法相同
    /**
    多个并发线程访问同一资源的同步代码块时
    同一时刻只能有一个线程进入synchronized（this）同步代码块
    当一个线程访问一个synchronized（this）同步代码块时，其他synchronized（this）同步代码块同    样被锁定
    当一个线程访问一个synchronized（this）同步代码块时，其他线程可以访问该资源的非             synchronized（this）同步代码
*/
}