Java 多线程

最新推荐文章于 2024-01-31 16:07:13 发布

淋雨一直走~

最新推荐文章于 2024-01-31 16:07:13 发布

阅读量253

点赞数

分类专栏： java 文章标签：多线程 java

本文链接：https://blog.csdn.net/qq_41579192/article/details/107122465

版权

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1 了解线程

1.1 什么是进程？

程序是静止的，运行中的程序就是进程。
进程的三个特征：
	 1. 动态性 ： 进程是运行中的程序，要动态的占用内存，CPU和网络等资源。
	 2. 独立性 ： 进程与进程之间是相互独立的，彼此有自己的独立内存区域。
	 3. 并发性 ： 假如CPU是单核，同一个时刻其实内存中只有一个进程在被执行。
           CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常
           快，给我们的感觉这些进程在同时执行，这就是并发性。

   并行:同一个时刻同时有多个在执行。

1.2 什么是线程？

线程是属于进程的。一个进程可以包含多个线程，这就是多线程。
线程是进程中的一个独立执行单元。
线程创建开销相对于进程来说比较小。
线程也支持“并发性”：线程可以参与竞争CPU执行自己！

1.3 线程的作用：

可以提高程序的效率，线程也支持并发性，可以有更多机会得到CPU。
多线程可以解决很多业务模型。
大型高并发技术的核心技术。
设计到多线程的开发可能都比较难理解。

2 线程的创建方式

拓展：线程的注意事项。
1.线程的启动必须调用start()方法。否则当成普通类处理。
– 如果线程直接调用run()方法，相当于变成了普通类的执行，此时将只有主线程在执行他们！
– start()方法底层其实是给CPU注册当前线程，并且触发run()方法执行
2.建议线程先创建子线程，主线程的任务放在之后。否则主线程永远是先执行完！

2.1 线程创建方式一继承 Thread 类

public class ThreadDemo {
    // 启动这个类，这个类就是进程，它自带一个主线程，
    // 是main方法，main就是一个主线程的执行！！
    public static void main(String[] args) {
        // 3.创建子线程对象
        Thread t = new MyThread();
        // 4.启动线程，必须用start()
        // 不能直接调用run()方法:如果直接调用run()方法当成普通类处理！
        // t.run();
        t.start();  // 线程对象注册给CPU ,参与并发执行！最终还是调用run()执行任务！！
        
        for(int i = 0 ; i < 10 ; i++ ) {
            System.out.println("main线程输出："+i);
        }
    }
}

// 1.定义一个线程类继承Thread
class MyThread extends Thread{
    // 2.重写run()方法
    @Override
    public void run() {
        for(int i = 0 ; i < 10 ; i++ ) {
            System.out.println("子线程输出："+i);
        }
    }
}

线程的常用API

/**
    目标：线程的常用API.

    Thread类的API:
        1.public void setName(String name):给当前线程取名字。
        2.public void getName():获取当前线程的名字。
            -- 线程存在默认名称，子线程的默认名称是：Thread-索引。
            -- 主线程的默认名称就是：main
        3.public static Thread currentThread()
            -- 获取当前线程对象，这个代码在哪个线程中，就得到哪个线程对象。
 */
public class ThreadDemo {
    // 启动后的ThreadDemo当成一个进程。
    // main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args) {
        /**
             // 创建一个线程对象
             Thread t1 = new MyThread();
             t1.setName("1号线程");
             t1.start();
             //System.out.println("t1线程："+t1.getName());

             Thread t2 = new MyThread();
             t2.setName("2号线程");
             t2.start();
             //System.out.println("t2线程："+t2.getName());

             // 获取当前线程对象。
             // 这个代码是哪个线程执行就会得到哪个线程对象。
             Thread m = Thread.currentThread();
             m.setName("最牛逼的线程");
             //System.out.println("主线程："+m.getName());

             for(int i = 0 ; i < 10 ; i++ ){
             System.out.println(m.getName()+"===>"+i);
             }
         */
        Thread thread = new MyThread();
        thread.start();
        Thread main = Thread.currentThread();
        main.setName("main");
        for (int i = 0; i < 10; i++) {
            System.out.println(main.getName()+i);
        }
    }
}

/**
// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
    // 2.重写run()方法
    @Override
    public void run() {
        // 线程的执行方法。
        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"===>"+i);
        }
    }
}
*/
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getId());
            System.out.println(Thread.currentThread().getName());
        }
    }
}

public static void main(String[] args) {
    for(int i = 0 ; i < 10  ; i++ ) {
        System.out.println("输出："+i);
        if(i == 5){
            try {
                // 让当前所在线程进入休眠状态，时间到继续抢占CPU执行自己！！
                // 项目经理让我加上这行代码，如果用户交钱了，我就去掉！
                Thread.sleep(6000); // 6s
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

/**
    目标：通过Thread类的有参数构造器为当前线程对象取名字。
        -- public Thread()
        -- public Thread(String name):创建线程对象并取名字。
 */
public class ThreadDemo03 {
    // 启动后的ThreadDemo当成一个进程。
    // main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args) {
        // 创建一个线程对象
        Thread t1 = new MyThread01("1号线程");
        t1.start();

        Thread t2 = new MyThread01("2号线程");
        t2.start();

        // 获取当前线程对象。
        // 这个代码是哪个线程执行就会得到哪个线程对象。
        Thread m = Thread.currentThread();
        m.setName("最牛逼的线程");


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

// 1.定义一个线程类继承Thread类。
class MyThread01 extends Thread{
    public MyThread01(String name){
        // public Thread(String name):创建线程对象并取名字。
        // 调用父类的有参数构造器为当前线程对象取名！
        super(name);
    }
    // 2.重写run()方法
    @Override
    public void run() {
        // 线程的执行方法。
        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"===>"+i);
        }
    }
}

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

/**
     多线程是很有用的，我们在进程中创建线程的方式有三种:
         （1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
          调用线程对象的start()方法启动线程。
         （2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
          线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
         （3）实现Callable接口（拓展）。
     b.实现Runnable接口的方式。
          -- 1.创建一个线程任务类实现Runnable接口。
          -- 2.重写run()方法
          -- 3.创建一个线程任务对象。
          -- 4.把线程任务对象包装成线程对象
          -- 5.调用线程对象的start()方法启动线程。
     Thread的构造器：
          -- public Thread(){}
          -- public Thread(String name){}
          -- public Thread(Runnable target){}
          -- public Thread(Runnable target,String name){}
     实现Runnable接口创建线程的优缺点：
          缺点：代码复杂一点。
             -- 不能直接得到线程执行的结果！
          优点：
            -- 线程任务类只是实现了Runnable接口，可以继续继承其他类，
                 而且可以继续实现其他接口（避免了单继承的局限性）
            -- 同一个线程任务对象可以被包装成多个线程对象
            -- 适合多个多个线程去共享同一个资源（后面内容）
            -- 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
            -- 线程池可以放入实现Runable或Callable线程任务对象。(后面了解)
               注意：其实Thread类本身也是实现了Runnable接口的。
 */
public class ThreadDemo {
    public static void main(String[] args) {
        /**
             // 3.创建一个线程任务对象。
             Runnable target = new MyRunnable();
             // 4.把任务对象包装成一个线程对象。
             // public Thread(Runnable target){}
             // public Thread(Runnable target，String name){}
             //Thread t = new Thread(target);
             Thread t = new Thread(target,"1号线程");
             // 5.调用线程对象的start方法启动线程
             t.start();
             Thread t1 = new Thread(target,"2号线程");
             // 6.调用线程对象的start方法启动线程
             t1.start();
             for(int i = 0 ; i < 10 ; i++ ){
                System.out.println(Thread.currentThread().getName()+"===>"+i);
             }
         */
        Runnable target = new MyRunnable();
        Thread thread = new Thread(target, "1号线程");
        thread.start();
        Thread thread2 = new Thread(target, "1号线程");
        thread2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "===>" + i);
        }
    }
}
/**
    // 1.创建一个线程任务类实现Runnable接口
    class MyRunnable implements Runnable{
        // 2.重写run()方法
        @Override
        public void run() {
            // 线程的执行方法。
            for(int i = 0 ; i < 10 ; i++ ){
                System.out.println(Thread.currentThread().getName()+"===>"+i);
            }
        }
    }
*/
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "===>" + i);
        }
    }
}

简化写法

public class ThreadDemo02 {
    public static void main(String[] args) {
        /**
             // 创建一个线程任务对象。
             Runnable target = new Runnable() {
            @Override
            public void run() {
            for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"===>"+i);
            }
            }
            };
             Thread t = new Thread(target);
             t.start();

             // 上面的简化写法！
             new Thread(new Runnable() {
            @Override
            public void run() {
            for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"===>"+i);
            }
            }
            }).start();
             for(int i = 0 ; i < 10 ; i++ ){
             System.out.println(Thread.currentThread().getName()+"===>"+i);
             }
         */
        // 常见一个线程任务对象
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"===>"+i);
                }
            }
        };
        Thread thread = new Thread(target);

        // 上面的简化方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"===>"+i);
                }
            }
        }).start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"===>"+i);
        }
    }
}

3.3 线程的创建方式三实现Callable接口

/**
     多线程是很有用的，我们在进程中创建线程的方式有三种:
         （1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
              调用线程对象的start()方法启动线程。
         （2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
              线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
         （3）实现Callable接口。
      c.线程的创建方式三: 实现Callable接口。
          -- 1,定义一个线程任务类实现Callable接口 ， 申明线程执行的结果类型。
          -- 2,重写线程任务类的call方法，这个方法可以直接返回执行的结果。
          -- 3,创建一个Callable的线程任务对象。
          -- 4,把Callable的线程任务对象包装成一个未来任务对象。
          -- 5.把未来任务对象包装成线程对象。
          -- 6.调用线程的start()方法启动线程
      优缺点：
          优点：全是优点。
             -- 线程任务类只是实现了Callable接口，可以继续继承其他类，
                    而且可以继续实现其他接口（避免了单继承的局限性）
             -- 同一个线程任务对象可以被包装成多个线程对象
             -- 适合多个多个线程去共享同一个资源（后面内容）
             -- 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
             -- 线程池可以放入实现Runable或Callable线程任务对象。(后面了解)
             -- 能直接得到线程执行的结果！
          缺点：编码复杂。
 */
public class ThreadDemo {
    public static void main(String[] args) {
        /**
             // 3.创建一个Callable的任务对象。
             Callable call = new MyCallable(10);
             // 4.把Callable的任务对象包装成一个未来任务对象。
             // --  public FutureTask(Callable<V> callable)
             // -- 未来任务对象的作用？
             //    1.未来任务对象本身就是一个Runnable的对象！
             //    2.未来任务对象可以在线程执行完毕之后得到线程执行的结果
             FutureTask<String> task = new FutureTask(call);
             // 5.把未来任务对象包装成一个线程对象
             Thread t = new Thread(task);
             // 6.启动线程对象
             t.start();

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

             // 7.得到线程执行的结果:通过get方法去取线程执行的结果值，以及异常结果！
             try {
             String rs = task.get();
             System.out.println(rs);
             } catch (Exception e) {
             e.printStackTrace();
             }
         */
        Callable call = new MyCallable(10);
        FutureTask<String> task = new FutureTask<>(call);
        Thread thread = new Thread(task);
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"===>"+i);
        }
        try {
            System.out.println(task.get());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

/**
     // 1.创建一个线程任务对象实现Callable接口，申明线程执行的结果的类型。
     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的和返回！
         int sum = 0 ;
         for(int i = 1 ; i <= n ; i++ ) {
             sum +=i ;
             System.out.println(Thread.currentThread().getName()+"===>"+i);
         }
            return Thread.currentThread().getName()+"执行的结果："+sum;
         }
     }
*/
class MyCallable implements Callable<String>{
    private  int n;
    public MyCallable(int n){
        this.n = n;
    }
    //重写call方法
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
            System.out.println(Thread.currentThread().getName() + "===>" + i);
        }
        return Thread.currentThread().getName() + "执行结果：" + sum;
    }
}

4 线程安全问题

线程同步的方式有三种：
（1）同步代码块。
（2）同步方法。
（3）lock显示锁。

对操作同意共享资源问题可能会出现线程安全问题，可以使用 线程同步 synchronized 来解决。具体使用方法不详细说明
c.lock显示锁。
java.util.concurrent.locks.Lock机制提供了比
synchronized代码块和synchronized方法更广泛的锁定操作,
同步代码块/同步方法具有的功能Lock都有,除此之外更强大
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
- public void lock():加同步锁。
- public void unlock():释放同步锁。(记得使用try catch finally 把unlock放在finally代码块上防止出现异常一直未释放锁)

淋雨一直走~

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java 多线程

1 了解线程1.1 什么是进程？程序是静止的，运行中的程序就是进程。进程的三个特征： 1. 动态性：进程是运行中的程序，要动态的占用内存，CPU和网络等资源。 2. 独立性：进程与进程之间是相互独立的，彼此有自己的独立内存区域。 3. 并发性：假如CPU是单核，同一个时刻其实内存中只有一个进程在被执行。 CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常快，给我们的感觉这些进程在同时执行，这就是并发性。并行:同一个
复制链接

扫一扫