JavaEE_day_22_线程介绍、生命周期、线程同步

目录

1. 并行并发
2. Thread(线程)
3. 线程优先级
4. 强制唤醒
5. join等待执行
6. yield让位
7. isStop终止线程
8. 锁

1.并行并发

并行: 多个任务同时刻开始执行(对于多个设备)
并发: 多个任务同时间片执行(对于单个设备)

2.Thread(线程)

• 创建线程有两种方式,但是启动线程只有一种方式,就是调用线程对象中的start()方法

创建线程的原理 :
找一个实现了run方法的实现类,传入Thread引用,进而调用Thread的start方法自动调用run方法

//多态,调用实现run方法类的一个实现类
  Thread t =new Processor();
  //线程开始
  t.start();


class Processor extends Thread{
 @Override
 //新创建的run实现类
 public void run() {
  for (int i = 0; i < 10; i++) {
   System.out.println("测试线程 : " + i);
  }
 }
}

通过创建

//main方法里
Thread t1 = new Thread(new process());
  Thread t2 = new Thread(new process());
  Thread t3 = new Thread(new Runnable(){
   @Override
   public void run() {
    for (int i = 0; i < 10; i++) {
     System.out.println(Thread.currentThread().getName());
    }
   }
  });
  t1.setName("t1");
  //启动时会自动调用run方法
  t1.start();
  t2.start();
  t3.start();

//创建一个实现了run方法的类,并传入Thread对象,才可以使用多线程
class process implements Runnable {
 @Override
 public void run() {
  try {
   for (int i = 0; i < 10; i++) {
    Thread.sleep(0);
    System.out.println(Thread.currentThread().getName());
   }
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
}

3.线程优先级

优先级 : java中分为10个等级,分别是1-10
 * 另外在Thread类中还提供了三个常量,分别保存1,5,10 优先级
 *   最高 : 10  Thread.MAX_PRIORITY
 *   正常 : 5  Thread.NORM_PRIORITY
 *   最低 : 1  Thread.MIN_PRIORITY
 * getPriority() : 获取该线程优先级
 * setPriority() : 设置该线程优先级

使用方法

thread.setPriority(Thread.MAX_PRIORITY);

4.强制唤醒

 interrupt : 强制唤醒某个线程
  // 1秒后 唤醒t线程
  t.interrupt();
 }
}
class  Processer_03 extends Thread{
 @Override
 public void run() {
  try {
   Thread.sleep(300000);
   System.out.println("哎呀,睡醒了");
  } catch (InterruptedException e) {
   e.printStackTrace();
   System.out.println("叮叮叮~闹钟响了");
  }
  System.out.println("开始上班");
 }
}

5.join等待执行

//等待当前线程执行完后才执行接下来 的线程
   thread.join();

6.yield让位

• 1 静态方法,意味着 写在哪个线程 , 哪个线程就让位
• 2 给相同的优先级线程让位,不同优先级不让位
• 3 该当前线程执行的执行的时候(拿到了时间片),把该执行机会(时间片) 让给其他线程

// 让位
   Thread.yield();
  写谁里面给谁让位

7.isStop终止线程

stop : 终止一个线程,容易出现问题,不太安全,不推荐使用
// 推荐使用标识符解决(自己创一个isStop布尔型变量)

t1.isStop = true;
// 判断是否终止
   if (isStop) {
    return;
   }

8.锁

• synchronized 隐式锁
  当多个线程同时访问某个对象时, 只允许一个线程访问, 那个线程出来后才能让下一个进入

public synchronized void withdraw(double money){
  //加上sleep会给先执行完的线程机会不被后面来的的线程追上
  try {
   Thread.sleep(500);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  this.balance -= money; 
 }

• lock 显示锁(一样的作用, 需要上锁并解开, 比隐式锁要更灵活, 可以自选段进行上锁)

//声明显示锁
private Lock lock = new ReentrantLock();
lock.lock();
  try {
   double after = balance - money;
   balance = after;
   System.out.println(Thread.currentThread().getName() + "取钱成功,取钱"
     + money + ",剩余" + balance + "元");
  }finally{
   // 解锁
   lock.unlock();
  }