JAVA多线程知识汇总

//方法一：
//定义Thread类的子类，并重写该类的run()方法
public class MyThreadDemo01 extends Thread {
  @Override
  public void run() {
    for (int i = 0; i < 20 ; i++) {
      System.out.println(getName()+"-->"+i);
    }
  }
}

//主线程
public class MainThread01 {
  public static void main(String[] args) {
    //创建Thread子类的实例，即创建了线程对象
    MyThreadDemo01 thread01 = new MyThreadDemo01();

    //调用线程对象的start()方法来启动该线程
    thread01.start();

    for (int i = 0; i < 10 ; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}

//方法二：
//定义Runnable接口的实现类，并重写该接口的run()方法，设置线程任务
public class MyThreadDemo02 implements Runnable{
  @Override
  public void run() {
    for (int i = 0; i < 10 ; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}

 //主线程
public class MainThread {
  public static void main(String[] args) {  
    //创建Runnable实现类对象
    MyThreadDemo02 runnable = new MyThreadDemo02();

    //创建Thread类的对象，并且该对象构造方法中传递Runnable实现类对象
    Thread thread02 = new Thread(runnable);

    //调用Thread对象的start()方法来启动线程
    thread02.start();

    for (int i = 0; i < 20 ; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}

//方法三：匿名内部类
public class MainThread {
  public static void main(String[] args) {
    //Thread方式
    new Thread(){
      @Override
      public void run() {
        for (int i = 0; i < 10 ; i++) {
          System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
      }
    }.start();
    //Runnable接口方式
	 new Thread(new Runnable() {
      @Override
      public void run() {
        for (int i = 0; i < 10 ; i++) {
          System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
      }
    }).start();
    ////////////////////////////////////////////////

    for (int i = 0; i < 20 ; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}

public class SafeRunnableDemo implements Runnable {
  private int ticket = 100;

  //同步代码块
  //创建锁对象
  Object lock = new Object();

  @Override
  public void run() {
    while (true){
      //锁住同步代码块
      synchronized (lock){
        if (ticket > 0) {
          System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张");
          ticket--;
        }
      }
    }
  }
}

public class SafeRunnableDemo implements Runnable {
  private int ticket = 100;

  //同步方法
  //定义一个同步方法
  public synchronized void lock(){
    //同步方法锁住代码块
    if (ticket > 0) {
      System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张");
      ticket--;
    }
  }

  //重写run并使用同步方法
  @Override
  public void run() {
    while (true){
      lock();
    }
  }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SafeRunnableDemo implements Runnable {
  private int ticket = 100;

  //Lock锁方法
  //创建ReentrantLock对象
  Lock lock = new ReentrantLock();
  @Override
  public void run() {
    while (true){
      //在可能出现问题的代码块之前用lock()方法
      lock.lock();
      if (ticket > 0) {
        System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张");
        ticket--;
      }
      //在可能出现问题的代码块之后用unlock()方法
      lock.unlock();
    }
  }
}

public class WaitAndSleep {
  public static void main(String[] args) {
    //创建锁对象
    Object lock = new Object();

    //匿名内部类创建线程1
    new Thread(){
      @Override
      public void run() {
        System.out.println(Thread.currentThread().getName()+"需要买票");
        //用同步代码块包裹
        synchronized (lock){
          try {
            //lock.wait(5000);//到5秒自动醒来
            lock.wait();//进入无限等待，需要唤醒
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        System.out.println(Thread.currentThread().getName()+"买到了票");
      }
    }.start();

    //匿名内部类创建线程2
    new Thread(){
      @Override
      public void run() {
        try {
          Thread.sleep(5000);//等待5秒
          System.out.println(Thread.currentThread().getName()+"出票了");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        //用同步代码块包裹
        synchronized (lock){
          lock.notify();//如果有多个线程等待，随机唤醒一个
          //lock.notifyAll();//唤醒所有等待的线程
        }
      }
    }.start();
  }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//线程池
public class ThreadPoolMain {
  public static void main(String[] args) {
    //使用线程池的工厂类 Executors里的静态方法 newFixedThreadPool
    // 生产指定线程数量的线程池，返回为ExecutorService接口
    ExecutorService es = Executors.newFixedThreadPool(2);

    //调用ExecutorService中的submit方法，传递线程任务，开启线程
    es.submit(new ThreadPoolDemo01());
  }
}

//////////////////////////////////////////////////////

//创建一个类实现Runnable接口，重写run方法，设置线程任务
public class ThreadPoolDemo01 implements Runnable{
  @Override
  public void run() {
    ...
  }
}