线程相关问题

文章目录

• 线程安全
• 线程同步
• • 同步代码块
  • 同步方法
  • Lock锁
• 线程通信
• 线程池
• • 实现线程池
  • • 线程池处理Runnable任务
    • Excutors处理Callable任务
    • Excutors工具类调用方法返回不同类型的线程池对象
• 定时器
• • Timer
  • ScheduledExecutorService
• 线程并发并行
• • 并发
  • 并行
• 生命周期

线程安全

多个线程同时 *** 作同一块共享资源时可能出现业务安全问题

 Account a=new Account("111",10);
 //创建俩个线程对象，代表俩个人同时进来
new DrawThread(a,"小米").start();
new DrawThread(a,"小红").start();

原因：存在多线程并发+同时访问共享资源+存在修改资源

线程同步

让多个线程实现先后依次访问共享资源，这样就解决了安全问题。加锁：让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

同步代码块

作用：把出现线程安全问题的核心代码上锁。
原理：每次只能进入一个线程，执行完毕后自动解锁，其他线程才能进来执行。

synchronized(同步锁对象）{
     *** 作共享资源的代码（核心代码）
  }

锁对象：只要对于当前同时执行的线程来说是同一个对象即可。
（1）锁对象用唯一的对象不好，因为会影响无关线程的执行。
（2）锁对象的规范要求：
建议使用共享资源作为锁对象。
对于实例方法建议使用this作为锁对象。
对于静态方法建议使用字节码（类名.class）对象作为锁对象。

 synchronized (this) {
   //判断账户余额
if (this.money >= money) {
  //取钱
System.out.println(name + "取钱成功");
  //变更余额
 this.money -= money;
    } else {
System.out.println("余额不足" + "剩余" + this.money);
         }
    }

同步方法

作用：把出现线程安全问题的核心方法上锁。同步代码块锁的范围更小，同步方法锁的范围更大。
原理：每次只能一个线程进入，执行完毕之后自动解锁，其他线程才可以进来执行。

修饰符 synchronized 返回值类型 方法名称(形参列表) {	
 *** 作共享资源的代码
}

底层原理：
（1）同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
（2）如果方法是实例方法：同步方法默认用this作为锁对象。但是代码要高度面向对象。
（3）如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

Lock锁

（1）Lock锁清晰表达如何加锁和释放锁。（2）Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定 *** 作。（3）Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。

private class Account{
  private final lock l=new ReentrantLock();
  public void drawmoney(double money) {
 //获取谁来取钱
String name = Thread.currentThread().getName();
l.lock();//上锁
try{//判断账户余额
if (this.money >= money) {
//取钱
System.out.println(name + "取钱成功");
 //变更余额
  this.money -= money;
    } else {
      System.out.println("余额不足" + "剩余" + this.money);
      }
  }finally{
      lock.unlock();
        }
     }

线程通信

(1)线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。通过共享一个数据的方式实现。

(2)根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

(3)线程通信实际场景：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

 public void run()
    {
        //创建来电提醒的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (phone.this) {
                        {
                           if(flag)
                           {
                               //此时应该接电话
                           }else{
                               //代表来电提醒
                               System.out.println("有电话进来");
                               flag=true;
                               phone.this.notify();
                               try {
                                   phone.this.wait();
                               } catch (InterruptedException e) {
                                   e.printStackTrace();
                               }
                           }
                        }
                    }
                }
            }
        }).start();
        
        //创建接电话的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                    synchronized (phone.this) {
                        if(flag){
                            System.out.println("电话接听中");
                            flag=false;
                            //等待自己，唤醒别人
                                phone.this.notify();
                               phone.this.wait();
                            } }
                            }
                        }catch (InterruptedException e) {
                          e.printStackTrace();
                    }
                }
            }
        ).start();
    }

线程池

（1）线程池就是一个可以复用线程的技术。
（2）不使用线程池会发生的问题： 如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

实现线程池

接口：ExecutorService
得到线程池对象：
ThreadPoolExecutor构造器的参数说明：
（1）临时线程什么时候创建：新任务提交的时候发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，这个时候才会创建临时线程。
（2）什么时候开始拒绝任务：核心线程和临时线程也在忙，任务队列也满了，心得任务过来才会拒绝任务。

线程池处理Runnable任务

最后一个参数的取值：

ExecutorService pools = new ThreadPoolExecutor(
3, 5 , 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6), 
 Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());

 Runnable target=new MyRunnable();
 pool.execute(target);
 pool.execute(target);

//关闭线程池一般不使用,立即关闭
pool.shutdownNow();
pool.shutdown();

Excutors处理Callable任务

//给任务线程池的处理
Future<String> f1=poll.submit(MyCallable(100));
Future<String> f2=poll.submit(MyCallable(200));

String rs=f1.get();
//拿到f1的字符串结果

Excutors工具类调用方法返回不同类型的线程池对象

Executors使用可能存在的陷阱：
大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

定时器

定时器是一种控制任务延时调用或者周期调用的技术

作用：闹钟，定时邮件发送
实现方式：Timer或ScheduledExecutorService

Timer

public Timer():
//创建临时定时器对象
public void schedule​(TimerTask task, long delay, long period)：
//开启一个定时器，按照计划处理TimerTask任务

特点：
（1）Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
（2）可能其中某个任务的异常使得Timer线程死掉，从而影响后续任务的执行

Timer timer=new Timer();
timer.shedule(new task(){
  public void run(){
  
  }
},3000,2000);

ScheduledExecutorService

基于线程池，某个任务的执行情况不影响其他定时任务的执行。

线程并发并行

正在运行的程序（软件）就是一个独立的进程， 线程是属于进程的，多个线程其实是并发与并行同时进行的。

并发

（1）CPU同时处理的线程数量有限
（2）CPU会轮询为系统的每个线程服务，由于CPU的切换速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行

在同一个时刻上，同时有多个线程在被CPU处理并且执行。
并发：CPU分时轮询的执行线程。
并行：同一个时刻同时在执行。

生命周期

（1）线程的状态：线程从生到死的过程，以及中间经历的各种状态及状态转换。
（2）Java线程的状态（6种）
6种状态都被定义在Thread类的内部枚举类中