第十章线程

最新推荐文章于 2024-07-09 16:46:46 发布

尧北生

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量63

点赞数

分类专栏：笔记文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/yaobeisheng/article/details/118342870

版权

笔记专栏收录该内容

16 篇文章 0 订阅

订阅专栏

第十章线程

一.程序 ,进程,线程

● 程序(program)是为完成特定任务、用某种语言编写的一

组指令的集合。即指一段静态的代码。

● 进程((process)就是正在执行的程序,从Windows角度讲，进程是操作系统进行资源分配的最小单位

● 线程(thread)进程可进一步细化为线程，是一个进程内部的最小执行单元，是操作系统进行任务调度的最小单元，隶属于进程

二.线程和进程的关系

● 一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行；

● 每一个进程至少包含一个线程(称为主线程)；在主线程中开始执行程序， java 程序的入口main()方法就是在主线程中被执行的。

● 在主线程中可以创建并启动其它的线程；

●一个进程内的所有线程共享该进程的内存资源。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j0KY74f1-1624968347119)(C:\Users\LENOVO\Desktop\程序_进程_线程png_wps图片.png)]

三.创建线程

1.Thread类

● 继承Thread类的方式

● 在Java中要实现线程，最简单的方式就是扩展Thread类，重写其中的run方法，方法原型如下：

● Thread类中的run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行 run方法。

/*
  创建线程,在线程中写可以独立执行的任务代码
 */
public class MyThread extends Thread{


    //run中写我们需要执行的任务代码
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("MyThread:"+i);
        }
    }


}

public class Test {

    public static void main(String[] args) {

         //在主线程中创建一个线程,并启动它
        MyThread myThread = new MyThread();
          //myThread.run(); 启动线程不能调用run(),就是普通的方法调用
          myThread.start();//启动线程

        for (int i = 0; i <1000 ; i++) {
            System.out.println("main:"+i);
        }

    }

2.Ruunable

/*
   好处:避免了单继承的局限,提高了扩展性
 */
public class MyThread implements  Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("MyThread:"+i);
        }
    }

}

public class Test {

    public static void main(String[] args) {

        //线程要执行的任务
        MyThread myThread = new MyThread();
        //创建线程,并为线程指定执行任务
        Thread t = new Thread(myThread);
               t.start();

        for (int i = 0; i <10000 ; i++) {
            System.out.println("main:"+i);
        }

    }
}

四.线程的优先级

● 事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务；

● 优先级较高的线程有更多获得CPU的机会，反之亦然；

● 优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；

public static void main(String[] args) {

     MyThread myThread = new MyThread();

     Thread t1 = new Thread(myThread,"t1");//创建线程对象,添加执行任务,并命名
            t1.start();

     Thread t2 = new Thread(myThread,"t2");
            t2.start();

            t1.setPriority(10);//设置优先,高优先级的执行优先权高(不是一直执行完)
            t2.setPriority(1);

   /*for (int i = 0; i <100 ; i++) {
        System.out.println(Thread.currentThread().getName()+":"+i);
    }*/

    System.out.println("=========="+t1.getPriority());//获得线程优先级
    System.out.println("=========="+t2.getPriority());
}

五.线程状态

● 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

● **就绪：**处于新建状态的线程被start（）后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源

● **运行：**当就绪的线程被调度并获得CPU资源时，便进入运行状态run 方法定义了线程的操作和功能

● **阻塞：**在某种特殊情况下，被人为挂起或执行输入输出操作时，让出

CPU并临时中止自己的执行，进入阻塞状态

● **死亡：**线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OEHSbfFp-1624968347123)(C:\Users\LENOVO\Desktop\屏幕截图 2021-06-29 192559.png)]

六.线程的分类

Java中的线程分为两类：用户线程和守护线程

用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束作。守护线程的作用是为其他线程的运行提供便利服务，守护线程最型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了注意:设置线程为守护线程必须在启动线程之前，否则会跑出一个 IllegalThreadStateException异常.

七.多线程

1.多线程的概念

多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多

个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行

执行的线程来完成各自的任务。

2.优点与缺点

优点:

(1)提高程序的相应.

(2)提高CPU的利用率

(3)改善程序结构,将复杂任务分为对个程序,独立运行.

缺点:

(1)线程也是程序，所以线程需要占用内存，线程越多占用内存也越多；

(2)多线程需要协调和管理，所以需要CPU时间跟踪线程；

(3)线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题；

3.线程同步

并发与并行:

● 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

● 并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事。

多线程同步:

● 多个线程同时读写同一

份共享资源时，可能会引起冲突。所以引入线程“同步”机制，即各线程间要有先来后到；

同步就是排队+锁：

● 几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；

● 为了保证数据在方法中被访问时的正确性，在访问时加入锁机制

实例:出票

public class MyThread extends Thread {
    static int num = 10;
    static Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {//同步锁 要求对象只有一个
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + "票数:" + num);
                    num--;
                } else {
                    break;
                }


            }
        }
    }

public class Text {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        t1.setName("窗口1");
        MyThread t2=new MyThread();
        t2.setName("窗口2");

         t1.start();
         t2.start();



    }

八.锁

• 从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

•java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

• ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

实例:交替打印1-100数字

public class PrintNumThread extends  Thread {

      static int num=0;
      static  Object obj  = new Object();

        @Override
        public void run() {
             while(true){
                 synchronized (obj){
                     obj.notify();//唤醒等待的线程,由于已经有线程持有锁了,也是不能进入到同步代码块
                     try {
                         Thread.sleep(500);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     if(num<100){
                         num++;
                         System.out.println(Thread.currentThread().getName()+":"+num);
                     }else{
                         break;
                     }
                     try {
                         obj.wait();//线程等待,释放锁
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
        }
}

九.新的创建线程方式

● 实现Callable接口与使用Runnable相比，Callable功能更强大些.

• 相比run（）方法，可以有返回值

• 方法可以抛出异常

• 支持泛型的返回值

• 需要借助FutureTask类，获取返回结果

接收任务

FutureTask futureTask = new FutureTask(任务);

创建线程

Thread t = new Thread(futureTask);

t.start();

Integer val = futureTask.

}


## 九.新的创建线程方式

● 实现Callable接口与使用Runnable相比，Callable功能更强大些. 

• 相比run（）方法，可以有返回值 

• 方法可以抛出异常 

• 支持泛型的返回值 

• 需要借助FutureTask类，获取返回结果 

接收任务 

FutureTask<Integer> futureTask = new FutureTask(任务); 

创建线程 

Thread t = new Thread(futureTask); 

t.start(); 

Integer val = futureTask.

get();获得线程call方法的返回值

尧北生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十章线程

第十章线程一.程序 ,进程,线程● 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。● 进程((process)就是正在执行的程序,从Windows角度讲，进程是操作系统进行资源分配的最小单位● 线程(thread)进程可进一步细化为线程，是一个进程内部的最小执行单元，是操作系统进行任务调度的最小单元，隶属于进程二.线程和进程的关系● 一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行；● 每一个进程至少包含一
复制链接

扫一扫