Java_线程

奋斗泉泉

已于 2024-07-06 21:19:53 修改

阅读量234

点赞数 8

文章标签： java

于 2024-07-03 07:04:19 首次发布

本文链接：https://blog.csdn.net/weixin_44738540/article/details/140141238

版权

什么是线程？

线程（Thread）是一个程序内部的一条执行流程

程序中如果只有一条执行流程，那这个程序就是单线程程序。

什么是多线程？

多线程是指从软硬件上实现的多条执行流程的技术(多条线程由CPU负责调度执行)。

如何在程序中创建出多条线程？

Java是通过java.lang.thread包来创造线程的。

  class PrimeThread extends Thread{
   
      long minPrime;
      PrimeThread(long minPrime)
      {
   
         this.minPrime = minPrime;
         
      }
      public void run()
      {
   
         //continue primes larger than
      }
  }

示例如下


public class ThreadTest1 {
   

    public static void main(String[] args) {
   
        //3、创建MyThread线程类的对象代表一个线程
         Thread t = new Thread();

         //4、启动线程（自动执行run方法）
         t.start();

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


}

// 1、让子类继承Thread 线程类
public class MyThread extends Thread{
   

        //2、必须重写Thread类的run方法
       @Override
    public void run()
       {
   
           //描述线程的执行任务。
           for(int i=1;i<=10;i++)
           {
   
               System.out.println(i);
           }
       }

}

多线程的创建方式一：继承Thread类

定义一个子类MyThread继承线程类java.lang.Thread,重写run()

创建MyThread类的对象

调用线程对象的start()方法启动线程(启动后还是执行run方法)

方式一优缺点：

优点：编程简单
缺点：线程类已经继承Thread，无法继承其他类，不利于功能扩展

多线程注意事项

1、启动线程必须是调用start方法，不是调用run方法

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
只有调用start方法才是启动一个新的线程执行

2、不要把主线程任务放在启动子线程之前

这样主线程一直是先跑完的，相当于是一个单线程的效果了。

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

定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理

Thread类提供的构造器	说明
public Thread(Runnable target)	封装Runnable对象成为线程对象

方式二的优缺点

优点：任务类只是实现接口，可以继续继承其他类、实现其他接口、扩展性强。


public class ThreadTest2 {
   
    public static void main(String[] args) {
   
         //3、创建任务对象
          Runnable target = new MyRunnable();

          //4、把任务交给一个线程对象去处理
         //public Thread (Runnable target)
        new Thread(target).start();

        for (int i = 0; i < 10; i++) {
   
            System.out.println( "主线程输出" + i);
        }
    }
}
public class MyRunnable implements Runnable {
   
    public void run() {
   
          //线程执行的任务
         for (int i = 0; i < 10; i++) {
   
             System.out.println("子线程输出"+i);
         }
    }
}

线程创建方式二的匿名内部类写法

1、可以创建Runnable的匿名内部类对象
2、再交给Thread线程对象
3、再调用线程对象的start()启动线程


public class Threadtest3 {
   
    public static void main(String[] args) {
   
        //1、直接创建Runnable接口的匿名内部类形势

        Runnable target = new Runnable() {
   
            @Override
            public void run(){
   
                for (int i = 0; i < 10; i++) {
   
                    System.out.println("子线程输出"+i);
                }
            }
        };

        new Thread(target).start();
        //简化形势
        new Thread(new Runnable(){
   
           @Override
           public void run(){
   
               for (int i = 0; i < 10; i++) {
   
                   System.out.println("子线程2输出"+i);
               }
           }
        }).start();

        for (int i = 0; i < 10; i++) {
   
            System.out.println("主线程main输出"+i);
        }
    }
}

多线程的第三种创建方式：利用Callable接口、FutureTask类来实现。

1、创建任务对象
定义一个类实现Callable接口，重写call方法，封装要做的事情，和返回的数据。
把Callable类型对象封装成FutureTask（线程任务对象）。

2、把线程任务对象交给Thread对象

3、调用Thread对象的start方法启动线程

4、线程执行完毕后、通过FutureTask（线程任务对象）

  //1、让这个类实现Callable接口
   public class MyCallable implements Callable<String>{
   
     private int n;
     public MyCallable(int n)
     {
    
       this.n =n;
     }
   //2、重写call方法
   @Override
   public String call() throws Exception{
   
      
       //描述线程的任务，返回线程执行返回后的结果
       //需求：求1-n的和返回。
       for(int i=1;i<n;i++)
       {
   
         sum+=i;
       }
    
      return "线程求出1-"+n+"的和是"+sum;
   }
   
   }

import java.sql.SQLOutput;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThreadTest2 {
   
    public static void main(String[] args) throws Exception {
   
         //3、创建一个Callable的对象
        Callable<String> callable = new MyCallable(100);

        //4、把Callable的对象封装成一个FutureTask对象(任务对象)
        //未来任务对象的作用？
        //1、是一个任务对象，实现了Runnable对象
        //2、可以在线程执行完毕之后，和未来任务对象调用get方法获取线程执行完毕后
        FutureTask<String> f1 = new FutureTask<>(callable);
        //5、把任务对象交给一个Thread对象
        new Thread(f1).start();


        Callable<String> call2 = new MyCallable(100);
        FutureTask<String> f2 =new FutureTask<>(call2);
        new Thread(f2).start();



        //6、获取线程执行完毕后返回的结果
        //注意：如果执行到这，假如上面的线程还没有执行完毕
        //这里的代码会暂停，等待上面线程执行完毕后才会返回
        String rs=f1.get();
        System.out.println(rs);

        String rs2 = f2.ge