多线程的创建方式和解决线程安全问题

最新推荐文章于 2021-09-02 16:04:05 发布

一只Java小白1111

最新推荐文章于 2021-09-02 16:04:05 发布

阅读量262

点赞数 1

分类专栏： java 文章标签： java 运维 c#

本文链接：https://blog.csdn.net/weixin_45943192/article/details/118556745

版权

java 专栏收录该内容

35 篇文章 2 订阅

订阅专栏

一基本概念

①程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

②进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

如：运行中的QQ，运行中的MP3播放器

程序是静态的，进程是动态的

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

③线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个进程同一时间并行执行多个线程，就是支持多线程的

线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小 一个进程中的多个线程共享相同的内存单元/内存地址空间。它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

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

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

二使用多线程的优点

背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点： 1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

2. 提高计算机系统CPU的利用率

3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

Thread类的有关方法

void start(): 启动线程，并执行对象的run()方法

run(): 线程在被调度时执行的操作

String getName(): 返回线程的名称 void setName(String name):设置该线程名称

static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类

static void yield()：线程让步

暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程；若队列中没有同优先级的线程，忽略此方法

join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止；低优先级的线程也可以获得执行

static void sleep(long millis)：(指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队；抛出InterruptedException异常

stop(): 强制线程生命期结束，不推荐使用

boolean isAlive()：返回boolean，判断线程是否还活着

三线程创建的方式

1、方式一：继承Threa类

1) 定义子类继承Thread类。

2) 子类中重写Thread类中的run方法。

3) 创建Thread子类对象，即创建了线程对象。

4) 调用线程对象start方法：启动线程，调用run方法。

代码如下：

/**
 * @Description 三个窗口卖票问题，总票数为100张
 * @Created by Administrator
 * @Date 2021/7/7 19:04
 * 线程创建方式一:继承Thread类
 * 1、创建一个继承于Thread类的子类
 * 2、重写Thread类的run()方法--->将线程的执行操作声明在run()中
 * 3、创建Thread类的子类的对象
 * 4、通过此对象调用start()
 */
public class ThreadTest1 {
    public static void main(String[] args) {
        //3、创建Thread类的子类的对象
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        //4、通过此对象调用start()
        t1.start();
        t2.start();
        t3.start();
    }
}

//1、创建一个继承于Thread类的子类
class Window extends Thread {
    private static int ticket = 100;

    //2、重写Thread类的run()方法--->将线程的执行操作声明在run()中
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

2、方式二：实现Runnable接口

1) 定义子类，实现Runnable接口。

2) 子类中重写Runnable接口中的run方法。

3) 通过Thread类含参构造器创建线程对象。

4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。

5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

代码如下：

/**
 * @Description 线程创建方式二：实现Runnable接口
 * @Created by Administrator
 * @Date 2021/7/7 19:24
 * 1、创建了一个实现实现Runnable接口的类
 * 2、实现类去实现Runnable中的抽象方法
 * 3、将此对象作为参数传递到Thread类的构造器中，创建Threa类的对象
 * 4、通过Thread类的对象调用start()
 */
public class ThreadTest2 {

    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        //4、通过此对象调用start()
        t1.start();
        t2.start();
        t3.start();
    }
}

class Window1 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

3、方式三：实现Callable接口

与使用Runnable相比， Callable功能更强大些

 相比run()方法，可以有返回值

 方法可以抛出异常

 支持泛型的返回值

 需要借助FutureTask类，比如获取返回结果

Future接口

 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。

 FutrueTask是Futrue接口的唯一的实现类

 FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值

代码如下：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @Description  遍历100以内的偶数，并求和
 * @Created by Administrator
 * @Date 2021/7/7 20:50
 * 方式三：实现Callable接口
 */
public class ThreadNew {
    public static void main(String[] args) {
        //3、创建Callable实现类的对象
        NumThread n=new NumThread();
        //4、将此Callable接口的实现类对象作为参数传递到FutureTask，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(n);
        //5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {  //get()返回值即为futureTask构造器参数实现Callable实现类重写call()的返回值
           Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//1、创建一个实现Callable的实现类
class NumThread implements Callable{
//2、实现call()方法，将此线程需要执行的操作声明在call（）中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for(int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }

        return sum;
    }
}

4、方式四：使用线程池

① 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

② 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

③好处： 1）提高响应速度（减少了创建新线程的时间）

2）降低资源消耗（重复利用线程池中线程，不需要每次都创建）

④便于线程管理

 corePoolSize：核心池的大小

 maximumPoolSize：最大线程数

 keepAliveTime：线程没有任务时最多保持多长时间后会终止

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

 ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

 void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行 Runnable

 <T>Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行 Callable

 void shutdown() ：关闭连接池

代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Description 方式四 ：使用线程池
 * @Created by Administrator
 * @Date 2021/7/7 21:12
 */
public class ThreadPol {
    public static void main(String[] args) {
        //1、提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2、执行指定的线程的操作，需要提供实现Runnable接口或者Callable接口实现类的对象
        service.execute(new Number());//适合适用于Runnable
//        service.submit();//适合适用于Callable
        //3、关闭线程池
        service.shutdown();
    }
}

class Number implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

四解决线程安全问题

1、方式一：采用同步代码块

synchronized (对象){

// 需要被同步的代码；

}

用实现继承Thread方式创建线程演示用同步代码块解决线程安全问题

public class ThreadTest2 {
    public static void main(String[] args) {

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        //4、通过此对象调用start()
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyThread extends Thread{
    //票数也需要设置为static，保证唯一，多个线程都操作这一百张票
    private static int ticket = 100;
    //方式一：该对象必须是静态的，保证唯一
    private static Object obj=new Object();

    @Override
    public void run() {
        while (true) {
            //此处也可以使用   synchronized (MyThread.class)  
            synchronized (obj) {    //同步代码块
                if (ticket > 0) {

                    try {   //线程睡眠，也就是阻塞
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

用实现Runnable接口创建线程演示用同步代码块解决线程安全问题

/**
 * @Description 通过同步代码块来解决实现Runnable接口的线程安全问题
 * @Created by Administrator
 * @Date 2021/7/7 19:50
 * 通过同步机制来解决线程安全问题
 *      方法一： 同步代码块
 *        synchronized(同步代码块){
 *            //需要同步的代码
 *        }
 *        说明：操作共享数据的代码，即为需要同步的代码块
 *        同步监视器：俗称 锁  任何一个类的对象都可以充当锁
 *            要求：多个线程必须共用一个锁
 */
public class ThreadTest3 {

    public static void main(String[] args) {
        Window2 w2 = new Window2();

        Thread t1 = new Thread(w2);
        Thread t2 = new Thread(w2);
        Thread t3 = new Thread(w2);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        //4、通过此对象调用start()
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window2 implements Runnable {

    private int ticket = 100;
    Object obj=new Object();  //充当锁，如果是继承方式创建Thread时需要加上static保证多个窗口共享
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {    //同步代码块
                if (ticket > 0) {

                    try {   //线程睡眠，也就是阻塞
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

2、方式二：采用同步方法

synchronized还可以放在方法声明中，表示整个方法为同步方法。例如：

public synchronized void show (String name){

….

}

非静态的同步方法，同步监视器是：this

静态的同步方法，同步监视器是：当前类本身

用继承方式创建的线程解决线程安全问题

public class ThreadTest3 {
    public static void main(String[] args) {
        MyThread2 t1 = new MyThread2();
        MyThread2 t2 = new MyThread2();
        MyThread2 t3 = new MyThread2();
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        //4、通过此对象调用start()
        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread2 extends Thread{
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    //同步监视器：当前类本身
    private static synchronized void show() {
        if (ticket > 0) {

            try {   //线程睡眠，也就是阻塞
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}

用实现Runnable接口方式创建的线程解决线程安全问题

/**
 * @Description 通过同步方法来解决实现Runnable接口的线程安全问题
 * @Created by Administrator
 * @Date 2021/7/7 20:12
 * 方式二 通过同步方法
 * 1、同步方法仍然涉及到同步监视器，只是不需要显示的声明
 * 2、非静态的同步方法，同步监视器this
 *    静态的同步方法，同步监视器是：当前类本身
 */
public class ThreadTeat4 {

    public static void main(String[] args) {
        Window3 w3 = new Window3();

        Thread t1 = new Thread(w3);
        Thread t2 = new Thread(w3);
        Thread t3 = new Thread(w3);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        //4、通过此对象调用start()
        t1.start();
        t2.start();
        t3.start();
    }
}

class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    //同步监视器：this
    private synchronized void show() { //如果是继承方式创建Thread时需要加上static
        if (ticket > 0) {

            try {   //线程睡眠，也就是阻塞
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}

3、方式三：采用Lock锁方式

class A{
    private final ReentrantLock lock = new ReenTrantLock();
        public void m(){
            lock.lock();
            try{
               //保证线程安全的代码;
            }
            finally{
                   lock.unlock();
                }
         }
   }

实用例子如下

import java.util.concurrent.locks.ReentrantLock;

/**
 * @Classname LockTets
 * @Description 解决线程安全方式三：Lock锁
 * @Date 2021/7/8 15:41
 * @Created by wangB
 */
class Window implements Runnable{

    private int ticket=100;
//实例化ReentrantLock
    private ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                //调用锁定方法
                lock.lock();

                if(ticket>0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+"；售票 ，票号为："+ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                //调用解锁方法
                lock.unlock();
            }
        }
    }
}

public class LockTets {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

五线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

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

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

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

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态

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

六线程通信

下面附上一个线程通信的例子：两个线程共同输出一到一百

/**
 * @Description 线程通信例子
 * @Created by Administrator
 * @Date 2021/7/9 9:44
 */
public class day11 {
    public static void main(String[] args) {
        Number n=new Number();

        Thread t1=new Thread(n);
        Thread t2=new Thread(n);

        t1.setName("线程1");
        t2.setName("线程2");

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


    }
}
class Number implements Runnable{
private int number=1;
    @Override
    public void run() {
        while(true){
            synchronized (this) {
                //唤醒线程
                notify();//一旦执行此方法 ，就会唤醒被wait的一个线程，如果有多个线程被wait，就会唤醒优先级高的

                if(number<=100){

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+" :"+number);
                    number++;
                    //使得调用如下方法的线程进入阻塞状态
                    try {
                        wait();//一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else {
                    break;
                }
            }
        }

    }
}

一只Java小白1111

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程的创建方式和解决线程安全问题

一基本概念①程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。②进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期如：运行中的QQ，运行中的MP3播放器程序是静态的，进程是动态的进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域③线程(thread)，进程可进一...
复制链接

扫一扫