java基础之Thread

线程

• 定义
  • 线程是程序执行的一条路径，一个进程中可以包含多条线程
• 优点
  • 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
• 线程通信
  • 为什么需要线程通信：多个线程并发执行时, 在默认情况下CPU是随机切换线程的
  • 怎么通信
    • 如果希望线程等待, 就调用wait()
    • 如果希望唤醒等待的线程, 就调用notify();
    • 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用
  • 多线程通讯
    • notify()方法是随机唤醒一个线程
    • notifyAll()方法是唤醒所有线程
• Thread类常用方法
  • getName()：获取线程对象的名字
  • setName(String)：可以设置线程对象的名字
  • Thread.currentThread()：获取当前线程对象
  • Thread.sleep(毫秒, 纳秒)：控制当前线程休眠若干毫秒
  • setDaemon()：设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
  • join()：当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
  • join(int)：可以等待指定的毫秒之后继续
  • yield(): 让出cpu
  • setPriority(): 设置线程的优先级
• 线程安全
  • 多线程并发操作同一数据时, 就有可能出现线程安全问题
  • 使用同步技术可以解决这种问题, 把操作数据的代码进行同步
  • 举例：
    • StringBuffer是线程安全的,效率低. StringBuilder是线程不安全的,效率高
    • Vector是线程安全的,效率低,ArrayList是线程不安全的,效率高
    • Hashtable是线程安全的,效率低,HashMap是线程不安全的,效率高
• 线程的同步
  • 同步代码块
    • 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
    • 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
    • 锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
  • 同步方法
    • 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
• 死锁问题

  • 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁

  • 尽量不要嵌套使用

      private static String s1 = "筷子左";
      private static String s2 = "筷子右";
      public static void main(String[] args) {
          new Thread() {
              public void run() {
                  while(true) {
                      synchronized(s1) {
                          System.out.println(getName() + "...拿到" + s1 + "等待" + s2);
                          synchronized(s2) {
                              System.out.println(getName() + "...拿到" + s2 + "开吃");
                          }
                      }
                  }
              }
          }.start();
      
          new Thread() {
              public void run() {
                  while(true) {
                      synchronized(s2) {
                          System.out.println(getName() + "...拿到" + s2 + "等待" + s1);
                          synchronized(s1) {
                              System.out.println(getName() + "...拿到" + s1 + "开吃");
                          }
                      }
                  }
              }
          }.start();
      }
    

创建线程的方式

继承Thread类

public class Demo {
    public static void main(String[] args) {
        MyThread mt = new MyThread(); //4, 创建自定义类的对象
        mt.start(); //5, 开启线程
    }
}

class MyThread extends Thread { //1, 定义类继承Thread
    public void run() { //2, 重写run方法
        for(int i = 0; i < 3000; i++) { //3, 将要执行的代码, 写在run方法中
            System.out.println("hello");
        }
    }
}

实现Runnable接口

public class Demo2 {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable(); //4, 创建自定义类对象
        Thread t = new Thread(mr); //5, 将 "自定义类对象" 当作参数传递给Thread的构造函数
        t.start(); //6, 开启线程
    }
}

class MyRunnable implements Runnable { //1, 自定义类实现Runnable接口
    @Override
    public void run() { //2, 重写run方法
        for(int i = 0; i < 3000; i++) { //3, 将要执行的代码写在run方法中
            System.out.println("hello");
        }
    }
}

匿名内部类实现两种线程的创建

// 继承Thread类
new Thread() { 
    public void run() {
        for(int i = 0; i < 3000; i++) {
            System.out.println("hello");
        }
    }
}.start();

// 实现Runnable接口
new Thread(new Runnable(){
    public void run() {
        for(int i = 0; i < 3000; i++) {
            System.out.println("hello");
        }
    }
}).start();