JAVA高级—多线程01

1.为什么使用多线程

1.提高响应速度：对于耗时操作，使用多线程可以使得应用程序更快地响应用户的请求，从而提高用户体验。

2。实现并行计算：多线程可以同时执行多个任务，从而实现并行计算，提高程序的运行效率。

3.提高CPU利用率：在多CPU系统中，使用多线程可以充分利用CPU资源，提高系统的运行效率。

4.改善程序结构：将一个既长又复杂的进程分为多个线程，可以使得程序更加模块化、易于理解和修改。

5.线程间通信机制：多线程之间可以方便地进行通信和协作，而不同进程之间则需要通过通信的方式进行数据传递，这种方式费时且不方便。

2.java中如何创建多线程

java中提供了三种实现多线程的方式

第一种：继承Thread类

第二种：实现Runnable接口

第三种：实现Callable接口

1.继承Thread类

//创建一个线程类
public class MyThread extends Thread{

    //run表示线程启动后执行的业务代码
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("~~~~~~~~~~~~~~~~~~"+i);
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
        //创建线程对象
        MyThread my=new MyThread();
        //开启线程--硬件底层调用线程的run方法
        my.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main~~~~~~~~~~~~~"+i);
        }
    }
}

设置和获取线程的名称

2.案例

public class SellTicket extends Thread {
    private int tick=100;
    @Override
    public void run() {
       while (true){
           if(tick>0){
               tick--;
               System.out.println(Thread.currentThread().getName()+"卖了一张票,剩余:"+tick+"张");
           }else{
               System.out.println(Thread.currentThread().getName()+"卖完了");
               break;
           }

       }
    }
}

3.实现Runnable接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程执行时的任务代码
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~"+i);
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
        //创建线程任务对象
        MyRunnable my=new MyRunnable();
        //创建线程对象
        Thread t1=new Thread(my,"线程名");
        t1.start();

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

    }
}

4.案例

public class SellTicket implements Runnable {
    private int tick = 100;

    @Override
    public void run() {
        while (true) {
            if (tick > 0) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                tick--;
                System.out.println(Thread.currentThread().getName() + "卖了一张票；剩余:" + tick + "张");
            } else {
                break;
            }
        }
    }
}

public class TestTick {
    public static void main(String[] args) {
        SellTicket task=new SellTicket();

        Thread t1=new Thread(task,"窗口A");
        Thread t2=new Thread(task,"窗口B");
        Thread t3=new Thread(task,"窗口C");
        Thread t4=new Thread(task,"窗口D");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

5.实现Callable接口

public class MyCallable implements Callable<Double> {
    //call表示线程的任务代码.
    @Override
    public Double call() throws Exception {
        double sum=0;
        for (int i = 0; i <=100 ; i++) {
            sum+=i;
        }
        return sum;
    }
}

public class Test01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable my=new MyCallable();

        //把call对象封装到FutureTask类中 而且任务执行的结果也在FutureTask
        FutureTask task=new FutureTask(my);
        Thread t=new Thread(task);

        t.start();

        Object o = task.get();
        System.out.println(o);
    }
}

6.案例

        求1~1000之间3的倍数之和

public class mycallable implements Callable<Double> {
    int a=0;
    @Override
    public Double call() throws Exception {
        for (int i=3;i<1000;i++){
            if (i%3==0){
                a+=i;
            }
        }
        return (double) a;
    }
}





public static void main(String[] args) throws Exception{
 mycallable mycallable=new mycallable();
        FutureTask futureTask = new FutureTask(mycallable);
        Thread t1=new Thread(futureTask,"AA");
        t1.start();
        Object o = futureTask.get();
        System.out.println(o);
    }
}