java-多线程2

dmhxm

已于 2023-08-11 14:31:41 修改

阅读量2.3k

点赞数

文章标签： java android 开发语言

于 2021-12-06 13:42:02 首次发布

本文链接：https://blog.csdn.net/weixin_44079370/article/details/121745098

版权

12.2知识点
1、匿名内部类实现多线程
1.1 Thread类实现

new Thread() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}.start();

1.2 Runnable接口实现

new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}).start();

2、线程安全
// 多线程程序，没有访问共享数据，不会产生问题
// 多线程程序，访问了共享数据，会产生线程安全问题
2.1 解决线程安全问题
2.1.1 第一种方式同步代码块（synchronized(锁对象)）
格式：
synchronized(锁对象) {
可能出现线程安全问题的代码（访问了共享数据）
}
注意：

通过代码块中的锁对象，可以使用任意的对象
但是必须保证多个线程使用的锁对象是同一个
锁对象的作用：
把同步代码块锁住，只让一个线程在同步代码块中执行
实现原理总结：
同步中的线程，没有执行完毕不会释放锁对象，同步外的线程没有锁对象进不去同步
代码示例：

public class RunnableImpl implements Runnable{
    // 设置总票数
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            // 同步代码块
            synchronized (this) {
                if (ticket > 0) {
                    // 提高安全问题出现的概率
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("正在卖第" + ticket + "张票");
                    ticket--;
                } else {
                    return;
                }
            }
         }
    }
}

    public static void main(String[] args) throws ParseException {
        RunnableImpl ri = new RunnableImpl();
        Thread thread1 = new Thread(ri);
        Thread thread2 = new Thread(ri);
        Thread thread3 = new Thread(ri);
        thread1.start();
        thread2.start();
        thread3.start();
    }

2.2.2 第二种方式同步方法（使用synchronized修饰方法）
使用步骤：

把访问了共享数据的代码抽取出来，放到方法中
在方法上添加synchronize修饰符
同步方法的锁对象就是this，静态同步方法的锁对象是本类的class属性，class文件对象(反射)
格式：
修饰符 synchronized 返回值类型方法名（参数列表）{
可能会出现线程安全问题的代码（访问了共享数据的代码）
}
同步方法代码示例：

    private int ticket = 100;

    @Override
    public synchronized void run() {
        while (true) {
            if (ticket > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("正在卖第" + ticket + "张票");
                ticket--;
            } else {
                return;
            }
        }
    }

静态同步方法代码示例：

        private static int ticket = 100;

        @Override
        public void run() {
            while (true) {
                ticketMain();
            }
        }

        public static synchronized void ticketMain () {
            if (ticket > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("正在卖第" + ticket + "张票");
                ticket--;
            } else {
                return;
            }
        }

2.2.2 第三种方式 Lock锁(同步锁)
java.util.concurrent.locks.Lock接口
Lock接口实现提供了比synchronized方法和语句可获得的更广泛的锁定操作
方法：
void lock(); // 加同步锁
void unlock(); // 释放同步锁
代码示例：

        public class RunnableImpl implements Runnable{
            private int ticket = 100;
            Lock lock = new ReentrantLock();
            @Override
            public void run() {
                while (true) {
                    lock.lock();
                    if (ticket > 0) {
                        try {
                            Thread.sleep(10);
                            System.out.println("正在卖第" + ticket + "张票");
                            ticket--;
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    }
                }
            }
        }

3、线程状态
NEW（新建）至今尚未启动的线程状态
RUNNABLE（运行）正在java虚拟机中执行的线程
BLOCKED（锁阻塞）受阻塞并等待某个监视器锁的线程
WAITING （无限等待）无限期等待另一个线程来执行某一特定操作的线程
TIMED_WAITING（计时等待）等待另一个线程来执行取决于指定等待时间的操作的线程
TERMINATED 已退出的线程

3.1 Object类中的方法
void wait() // 在其他线程调用此对象的notify()方法或者notifyAll()方法前，导致当前线程等待
void notify() // 唤醒在此对象监视器上等待的单个线程。会继续执行wait方法之后的代码
void notifyAll // 唤醒在此对象监视器上等待的所有线程。
代码示例：

    // 创建锁对象
    Object obj = new Object();
    // 创建一个顾客线程
    new Thread() {
        @Override
        public void run() {
            // 保证等待和唤醒的线程只能有一个执行，需要使用同步技术
            synchronized (obj) {
                System.out.println("告知要吃的包子的种类和数量");
                // 调用wait方法，放弃cpu执行，进入到WAITTING状态（无限等待）
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 唤醒后执行的代码
                System.out.println("开吃");
            }
        }
    }.start();
// 创建一个老板线程，做包子
new Thread() {
        @Override
        public void run() {
            // 等待五秒钟，做包子
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj) {
                System.out.println("包子做好了，告知顾客吃包子");
                // 唤醒顾客吃包子
                obj.notify();
            }
        }
    }.start();

4、线程池
线程池其实就是一个容纳线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多的资源
线程池实现原理：底层是集合，存放的线程对象
4.1 java.util.concurrent.Executors类
// 线程池的工厂类，用来生产线程池
4.1.1. Executors类中的静态方法
static ExecutorService newFixedThreadPool(int nThreads)
// 创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程，在需要时使用提供的 ThreadFactory 创建新线程。
参数：
int nThreads：创建线程池中包含的线程数量
返回值：
ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口来接收（面向接口编程）
4.1.2 java.util.concurrent.ExecutorService：线程池接口
// 用来从线程池中获取线程，调用start方法，执行线程任务
submit(Runnable task) // 提交一个Runnable任务用于执行
void shutdown() // 关闭/销毁线程池的方法
4.1.3 线程池的使用步骤

使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定数量的线程池
创建一个类，实现Runnable接口，重写run方法，设置线程任务
调用ExecutorService接口中的方法submit，传递线程任务（实现类），开启线程，执行run方法
调用ExecutorService接口中的shutdown方法，销毁线程池（不建议执行）
代码示例：

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        executorService.shutdown();
    }

dmhxm

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java-多线程2

12.2知识点1、匿名内部类实现多线程1.1 Thread类实现new Thread() {@Overridepublic void run() {for (int i = 0; i < 20; i++) {System.out.println(Thread.currentThread().getName() + "–>" + i);}}}.start();1.2 Runnable接口实现new Thread(new Runnable() {@Overridepubl
复制链接

扫一扫