Java 创建多线程

超、凢脫俗 2024-04-01 13:13 53阅读 0赞

**目录**

1.方式一：

2.方式二：

3.两种方式的区别：

4.两种方式的相同点：

5.方式三：

6.方式四：

Java里创建多线程的方式有四种，分别如下所示：

### 1.方式一： ###

（1）创建一个子类继承Thread

（2）重写里面的run方法

（3）实例化子类对象

（4）调用start方法，用于启动线程，运行重写的run方法

package MultiThreads;
    //分别创建两个线程，用于输出奇数和偶数
    public class demo2 {
        public static void main(String[] args) {
            myThread1 t1=new myThread1();
            myThread2 t2=new myThread2();
            t1.start();
            t2.start();
        }
    }
    class myThread1 extends Thread{
        @Override
        public void run() {
            for (int i = 1; i < 100; i++) {
                if(i%2==0) System.out.println("*****"+i+"*******");
    
            }
        }
    }
    class myThread2 extends Thread{
        @Override
        public void run() {
            for (int i = 1; i < 100; i++) {
                if(i%2!=0){
                    System.out.println(i);
                }
            }
        }
    }

### 2.方式二： ###

（1）创建一个实现类实现接口Runnable，

（2）重写run方法

（3）创建实现类对象

（4）创建Thread对象，带参构造，参数为上述实现类对象

（5）调用start方法

package MultiThreads;
    
    public class demo4 {
        public static void main(String[] args) {
            mythread4 mt=new mythread4();
            Thread t= new Thread(mt);
            t.start();
        }
    }
    class mythread4 implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if(i==3||i==6){
                    System.out.println("pww");
                }
            }
        }
    }

### 3.两种方式的区别： ###

开发中优先选择第二种，实现Runnable接口的方式。

（1）实现的方式没有类的单继承性的局限性

（2）实现的方式更适合处理多个线程有共享数据的情况

### 4.两种方式的相同点： ###

都需要重写run方法，将线程 需要执行的代码放在run中

### 5.方式三： ###

（1）创建Callable接口的实现类

（2）重写call方法

（3）创建实现类对象

（4）借用FutureTask实现类对象作为参数去创建Thread线程

（5）调用start方法运行线程

package MultiThreads;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class demo11 {
        public static void main(String[] args) {
    
            NumThread nt=new NumThread();
            FutureTask ft=new FutureTask(nt);
            Thread t=new Thread(ft);
            t.start();
            for (int i = 0; i < 50; i++) {
                System.out.println("*****************************");
            }
            try {
                Object sum=ft.get();
                System.out.println("总和为："+sum);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } catch (ExecutionException e) {
                throw new RuntimeException(e);
            }
    
    
        }
    }
    class NumThread implements Callable{
        @Override
        public Object call() throws Exception {
            int sum=0;
            for (int i = 1; i < 100; i++) {
                if(i%2==0){
                    System.out.println(i);
                    sum+=i;
                }
            }
            return sum;
        }
    }

### 6.方式四： ###

使用线程池创建

（1）提供指定线程数的线程

（2）提供指定线程的任务

（3）关闭连接池

package MultiThreads;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class demo12 {
        public static void main(String[] args) {
            //提供指定线程的线程池
            ExecutorService Service = Executors.newFixedThreadPool(10);
            //执行指定线程的任务
            Service.execute(new my_thread());
            Service.execute(new my_thread2());//适用于Runnable
            //Service.submit(Callable callable);适用于Callable
            Service.shutdown();//关闭连接池
    
        }
    }
    class my_thread implements Runnable{
        @Override
        public void run() {
            for (int i = 1; i < 100; i++) {
                if(i%2==0){
                    System.out.println(Thread.currentThread().getName()+" "+i);
                }
            }
        }
    }
    class my_thread2 implements Runnable{
        @Override
        public void run() {
            for (int i = 1; i < 100; i++) {
                if(i%2!=0){
                    System.out.println(Thread.currentThread().getName()+" "+i);
                }
            }
        }
    }