多线程

        System.out.println(Thread.currentThread().getName()+"===" + i);

    }
}

}

线程的执行

假如我们的计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，
线程只有得到 CPU时间片，也就是使用权，才可以执行指令。

线程调度的两种模式

分时调度模型

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

抢占式调度模型

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。 Java使用的是抢占式调度模型。

设置线程的优先级

public final int getPriority() //获取线程的优先级
public final void setPriority(int newPriority)//设置线程的优先级

线程休眠

线程休眠: public static void sleep(long millis) 线程休眠

列:

public static void main(String[] args) throws InterruptedException {

    System.out.println("这是一段广告");
    Thread.sleep(5000);
    System.out.println("bbbbb");
    //Thread(String name) 分配新的 Thread 对象。
    MyThread th1 = new MyThread("林青霞");
    th1.start();
}

public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}

@Override
public void run() { //需要线程来执行的方法
    //一般run方法里面写的就是耗时操作
    for (int i = 0; i < 100; i++) {
        try {
            Thread.sleep(2000);//让线程休眠
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //System.out.println(this.getName()+"=="+i);
        System.out.println(Thread.currentThread().getName() + "===" + i);

    }
}

}

加入线程

加入线程: public final void join()
意思就是: 等待该线程执行完毕了以后,其他线程才能再次执行
注意事项: 在线程启动之后,在调用方法

列:

public class MyTest {
public static void main(String[] args) throws InterruptedException {
MyThread th1 = new MyThread("刘备");
MyThread th2 = new MyThread("关羽");
MyThread th3 = new MyThread("张飞");

    //join()方法可以将多个线程并发的执行，转换成串行
    //A:
    //加入线程:
    //public final void join ()
    //意思就是:
    //等待该线程执行完毕了以后, 其他线程才能再次执行
    //注意事项:
    //在线程启动之后, 在调用方法
    th1.start();
    th1.join();
    th2.start();
    th2.join();
    th3.start();
}

}
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}

@Override
public void run() { //需要线程来执行的方法
    //一般run方法里面写的就是耗时操作
    for (int i = 0; i < 100; i++) {

        System.out.println(Thread.currentThread().getName() + "===" + i);

    }
}

}

礼让线程

礼让线程: public static void yield(): 暂停当前正在执行的线程对象，并执行其他线程。

列:

public class MyTest {
public static void main(String[] args) {
MyThread th1 = new MyThread("刘备");
MyThread th2 = new MyThread("关羽");
th1.start();
th2.start();

}

}
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}

@Override
public void run() { //需要线程来执行的方法
    //一般run方法里面写的就是耗时操作
    for (int i = 0; i < 100; i++) {
        Thread.yield();//线程礼让
        System.out.println(Thread.currentThread().getName() + "===" + i);

    }
}

}

守护线程

守护线程: public final void setDaemon(boolean on):
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。

列:

public class MyTest {
public static void main(String[] args) {
Thread.currentThread().setName("刘备");
System.out.println("主线程开始了");
System.out.println("主线程开始了");
System.out.println("主线程开始了");
System.out.println("主线程开始了");

    //A:
    //守护线程:
    //public final void setDaemon ( boolean on):
    //将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
    //该方法必须在启动线程前调用。
    //当用户线程，执行完之后，那么守护线程，必须里面死亡
    MyThread th1 = new MyThread("张飞");
    MyThread th2 = new MyThread("关羽");
    //设置为守护线程 该方法必须在启动线程前调用。
    th1.setDaemon(true);
    th2.setDaemon(true);
    th1.start();
    th2.start();

    System.out.println("主线程结束了");
    System.out.println("主线程结束了");
    System.out.println("主线程结束了");
    System.out.println("主线程结束了");
    System.out.println("主线程结束了");

}

}
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}

@Override
public void run() { //需要线程来执行的方法
    //一般run方法里面写的就是耗时操作
    for (int i = 0; i < 100; i++) {
        System.out.println(Thread.currentThread().getName() + "===" + i);

    }
}

}

java用户线程和守护线程

• 1.用户线程和守护线程的区别
  用户线程和守护线程都是线程，区别是Java虚拟机在所有用户线程dead后，程序就会结束。而不管是否还有守护线程还在运行，若守护线程还在运行，则会马上结束。很好理解，守护线程是用来辅助用户线程的，如公司的保安和员工，各司其职，当员工都离开后，保安自然下班了。

线程安全问题产生的原因

JDK5之后的Lock锁的概述和使用

• Lock锁的概述
  虽然我们可以理解同步代码块和同步方法的锁对象问题，
  但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
  为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

• Lock和ReentrantLock
  void lock()
  void unlock()
  public class CellRunable implements Runnable {
  static int piao = 100;
  static Object obj = new Object();
  static Lock lock = new ReentrantLock();

  列:

  @Override
  public void run() {

  while (true) {
      lock.lock(); //加锁
      if (piao > 0) {
  
          try {
              Thread.sleep(20);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
  
          System.out.println(Thread.currentThread().getName() + "正在售卖 " + (piao--) + " 张票");
      }
  
      lock.unlock(); //释放锁
  }

  }

}
public class MyTest {
public static void main(String[] args) {
/ A:
Lock锁的概述
虽然我们可以理解同步代码块和同步方法的锁对象问题，
但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
B:
Lock和ReentrantLock
void lock ()
void unlock ()/

    CellRunable cellRunable = new CellRunable();
    Thread th1 = new Thread(cellRunable);
    Thread th2 = new Thread(cellRunable);
    Thread th3 = new Thread(cellRunable);
    th1.setName("窗口1");
    th2.setName("窗口2");
    th3.setName("窗口3");
    th1.start();
    th2.start();
    th3.start();
}

}

死锁

列:

    //方式2
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("线程执行了");
        }
    }).start();
}

}

定时器

• 定时器概述
  定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。
  在Java中，可以通过Timer和TimerTask类来实现定义调度的功能。
• Timer和TimerTask
  Timer:
  public Timer()
  public void schedule(TimerTask task, long delay):
  public void schedule(TimerTask task,long delay,long period);
  public void schedule(TimerTask task, Date time):
  public void schedule(TimerTask task, Date firstTime, long period):
  TimerTask
  public abstract void run()
  public boolean cancel()

• 开发中
  Quartz是一个完全由java编写的开源调度框架。

  列:

  public class MyTest {
  public static void main(String[] args) throws ParseException {
  //定时器：Timer

  // 一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。
  Timer timer = new Timer();
  //可以到时间执行任务
  //void schedule (TimerTask task, Date time)
  //安排在指定的时间执行指定的任务。
  //void schedule (TimerTask task, Date firstTime,long period)
  //安排指定的任务在指定的时间开始进行重复的固定延迟执行。
  //void schedule (TimerTask task,long delay)
  //安排在指定延迟后执行指定的任务。
  //void schedule (TimerTask task,long delay, long period)
  //安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
  
  //TimerTask由 Timer 安排为一次执行或重复执行的任务。
  //boolean cancel ()
  //取消此计时器任务。
  MyTimerTask myTimerTask = new MyTimerTask(timer);
  //timer.schedule(myTimerTask, 3000); //2秒之后执行定时任务
  // timer.schedule(myTimerTask,2000,1000);//第一次等2秒执行，后面每隔一秒重复执行。
  //myTimerTask.cancel();取消定时任务
  
  //在指定的日期来执行任务
  String str = "2019-05-17 15:45:00";
  Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(str);
  
  timer.schedule(myTimerTask, date);
  
  // timer.cancel();取消定时器

  }
  }
  public class MyTimerTask extends TimerTask {
  Timer timer;
  public MyTimerTask(Timer timer) {
  this.timer=timer;

  }

  @Override
  public void run() {
  System.out.println("砰~~~ 爆炸了");
  //timer.cancel();
  }
  }