在操作系统中，正在运行的程序称为进程，进程负责程序内存空间的分配。
进程包含线程，每条线程都是进程中代码的一条执行路径，是进程的实际运作单位。
一个进程中可以并发多个线程，每条线程并行执行不同的任务。
在一个进程中有多个线程同时在执行不同的任务的行为。
一个Java应用程序中至少有两个线程：一个是主线程，负责main方法代码的执行，一个是垃圾回收器线程，负责回收垃圾。
能让一个进程同时执行多个任务，提高资源的利用率（不是效率）。
增加了CPU的负担，降低了一个进程中线程的执行概率。
会引发线程安全问题，出现了死锁现象。
public class Main { public static void main(String[] args) { 1.继承方式开启线程 Demo1 demo = new Demo1(); demo.start(); 2.实现接口方式开启线程 Demo2 demo2 = new Demo2(); Thread thread = new Thread(demo2); thread.start(); } } 1.继承方式开启线程 class Demo1 extends Thread { @Override public void run() { super.run(); } } 2.实现接口方式开启线程 class Demo2 implements Runnable { @Override public void run() { } }匿名内部类方式开启线程 public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { } }).start(); }Runnable实现类的对象，不是线程对象，只是Runnable实现类的对象。
只有Thread或者Thread子类的对象才是线程对象，所以需要将Runnable实现类对象作为参数，放入Thread构造方法中。推荐使用接口实现的方式，因为Java的单继承，多实现。
从源码看，Runnable实现类的对象作为实参传递给Thread的作用 //SellTicket是Runnable的实现类 SellTicket sellTicket = new SellTicket(); //开启一个线程，将sellTicket传入，看这一段的源码 Thread thread1 = new Thread(sellTicket, "1号"); //源码 public Thread(Runnable target, String name) { init(null, target, name, 0); } //Thread的构造方法接收sellTicket，然后看看Thread.run()开启线程源码 @Override public void run() { if (target != null) { target.run(); } } //意思是在Thread类的run中调用了将传入的实现类的run方法，因此能开启线程| 方法 | 作用 |
|---|---|
| setName(String name) | 设置线程名称 |
| getName() | 获取线程名称 |
| setPriority(int prioity) | 设置线程的优先级(1~10) |
| getPriority() | 获取线程的优先级 |
public static void main(String[] args) { Thread thread = new Thread(new Demo(), "线程1"); thread.setName("重新设置线程名称"); System.out.println(thread.getName()); // 线程的优先级默认为5,优先级的范围为1~10 thread.setPriority(10); thread.getPriority(); Thread.currentThread().getPriority(); thread.start(); } class Demo implements Runnable { @Override public void run() { } }| 静态方法 | 作用 |
|---|---|
| sleep(long time) | 在哪个线程调用，哪个就睡眠 |
| currentThread() | 在哪个线程调用，就返回哪个线程的对象 |
public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new Demo(), "线程1"); Thread.sleep(1000); //主线程睡眠 Thread threadMain = Thread.currentThread(); //返回主线程对象 System.out.println("返回主线程：" + threadMain.getName()); thread.start(); } class Demo implements Runnable { @Override public void run() { // 为什么这里的异常只能捕获处理，不能抛出处理。 //因为Thread类的run()方法没有抛出异常，因此子类不能抛出。 try { Thread.sleep(1000); //子线程睡眠 Thread threadChild = Thread.currentThread();//返回子线程对象 System.out.println("返回子线程：" + threadChild.getName()); } catch (InterruptedException e) { e.printStackTrace(); } } }public static void main(String[] args) { Timer定时器工具类，会在主线程之外发起一个单独的线程执行指定的计划任务。 TimerTask是一个实现了Runnable接口的抽象类，代表一个可以被Timer执行的任务。 new Timer().schedule(new TimerTask() { int count = 0; @Override public void run() { System.out.println("" + count++); } }, 1000, 2000);1s后执行，每隔2s触发一次 }存在两个或两个以上的线程对象，操作共享同一个资源。
public static void main(String[] args) { SellTicket sellTicket = new SellTicket(); for (int i = 1; i <= 3; i++) new Thread(sellTicket, "线程" + i).start(); } class SellTicket implements Runnable { //待售票 //这里区别于Thread的方式，不需要用static，因为操作的是一个对象 private int ticket = 50; @Override public void run() { while (true) { if (ticket > 0) { System.out.println( Thread.currentThread().getName() + "销售了第：" + ticket + "号票"); ticket--; } else { System.out.println("票已售完"); break; } } } }线程紊乱
1.使用synchronized 同步代码块解决
synchronized (锁对象){ } 注意 1.任意的对象都可以作为锁对象，但是，多线程操作的锁对象必须是共享唯一的对象，可用Object。 2.只有真正存在线程安全问题的时才使用同步代码块，否则会降低效率。 3.在同步代码块中调用了sleep()方法，并不释放锁。 4.凡是对象内部都维护了一个状态，Java同步机制就是使用这个状态作为锁的标识。class SellTicket implements Runnable { private int ticket = 50; @Override public void run() { while (true) { //添加同步代码块 synchronized (this) { if (ticket > 0) { System.out.println( Thread.currentThread().getName() + "销售了第：" + ticket + "号票"); ticket--; } else { System.out.println("票已售完"); break; } } } } }2.使用 synchronized 同步函数解决
将 synchronized 添加到需要同步的函数上 public synchronized void run() { } 注意 1.同步函数的锁对象是固定的，不能由自己指定。 2.如果是一个非静态的同步函数，那么它的锁对象是this，它本身。 3.如果是静态的同步函数，那么它的锁对象是当前函数所属类的字节码文件(class对象)。class SellTicket implements Runnable { private int ticket = 50; @Override //添加同步函数 public synchronized void run() { while (true) { if (ticket > 0) { System.out.println( Thread.currentThread().getName() + "销售了第：" + ticket + "号票"); ticket--; } else { System.out.println("票已售完"); break; } } } } 推荐使用同步代码块 1.同步代码块的锁对象可以自由指定，方便控制，而同步函数的锁对象是固定的。 2.同步代码块可以控制同步代码的范围，同步函数作用范围是整个函数，将函数内所有代码都同步。3.使用 Lock 来代替 synchronized
public static final ReentrantLock LOCK = new ReentrantLock(); public void run() { LOCK.lock(); try { //线程的操作资源 } finally { LOCK.unlock(); } }class SellTicket implements Runnable { private int ticket = 50; public static final ReentrantLock LOCK = new ReentrantLock(); @Override public void run() { while (true) { LOCK.lock(); try { if (ticket > 0) { System.out.println( Thread.currentThread().getName() + "销售了第：" + ticket + "号票"); ticket--; } else { System.out.println("票已售完"); break; } } finally { LOCK.unlock(); } } } }1.使用 wait()，notify() 实现线程通信
线程通信指当一个线程完成自己的任务时，就去通知另外一个线程去完成另外一个任务。 wait() 1.线程执行wait()后，将进入以锁对象为标识符的线程池中等待。 2.等待状态下，只能被其他线程调用notify()才能唤醒。 3.执行wait()会释放锁。 notify() 线程执行了notify()后，将唤醒以锁对象为标识符在线程池中等待的线程中的一个。 notifyAll() 唤醒线程池中所有等待的线程。 注意 1.wait()，notify()必须由锁对象调用。 2.wait()，notify()必须在同步代码块或者同步函数中使用。 3.wait()，notify()是属于Object内的方法。典型模式：生产者不断生产商品，消费者不断消费商品。 public static void main(String[] args) { Product product = new Product(); new Thread(new Producer(product)).start(); new Thread(new Consumer(product)).start(); } // 产品类 class Product { private String name; private double price; // 产品是否生产的标志，默认没有生产完成 boolean flag = false; public String getName() { return name; } public void setName(String name) { this.name = name; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } public boolean isFlag() { return flag; } public void setFlag(boolean flag) { this.flag = flag; } } //生产者 class Producer implements Runnable { private Product mProduct; public Producer(Product product) { mProduct = product; } @Override public void run() { int i = 0; while (true) { synchronized (mProduct) { if (mProduct.isFlag() == false) { if (i % 2 == 0) { mProduct.setName("苹果"); mProduct.setPrice(10.5); } else { mProduct.setName("樱桃"); mProduct.setPrice(20.5); } i++; System.out.println("生产者：生产了：" + mProduct.getName() + "价格为：" + mProduct.getPrice()); mProduct.setFlag(true); mProduct.notify(); //唤醒消费者消费 } else { try { mProduct.wait();// 已经生产完毕，等待消费 } catch (InterruptedException e) { e.printStackTrace(); } } } } } } //消费者 class Consumer implements Runnable { private Product mProduct; public Consumer(Product product) { mProduct = product; } @Override public void run() { while (true) { synchronized (mProduct) { if (mProduct.isFlag() == true) { System.out.println("消费者：消费了：" + mProduct.getName() + "价格为：" + mProduct.getPrice()); mProduct.setFlag(false); mProduct.notify(); }else{ try { mProduct.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } }2.使用 Lock、Condition 实现线程通信
public static final ReentrantLock LOCK = new ReentrantLock(); public static final Condition CONDITION = LOCK.newCondition(); ReentrantLock：用来解决线程安全问题 Condition：用来实现线程通信 CONDITION.signalAll()：唤醒等待线程 CONDITION.await()：使线程等待// 产品类 class Product { private String name; private double price; // 产品是否生产的标志，默认没有生产完成 boolean flag = false; public static final ReentrantLock LOCK = new ReentrantLock(); public static final Condition CONDITION = LOCK.newCondition(); public String getName() { return name; } public void setName(String name) { this.name = name; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } public boolean isFlag() { return flag; } public void setFlag(boolean flag) { this.flag = flag; } } //生产者 class Producer implements Runnable { private Product mProduct; public Producer(Product product) { mProduct = product; } @Override public void run() { int i = 0; while (true) { Product.LOCK.lock(); try { if (mProduct.isFlag() == false) { if (i % 2 == 0) { mProduct.setName("苹果"); mProduct.setPrice(10.5); } else { mProduct.setName("樱桃"); mProduct.setPrice(20.5); } i++; System.out.println("生产者：生产了：" + mProduct.getName() + "价格为：" + mProduct.getPrice()); mProduct.setFlag(true); Product.CONDITION.signalAll(); } else { Product.CONDITION.await(); } } catch (InterruptedException e) { e.printStackTrace(); } finally { Product.LOCK.unlock(); } } } } //消费者 class Consumer implements Runnable { private Product mProduct; public Consumer(Product product) { mProduct = product; } @Override public void run() { while (true) { Product.LOCK.lock(); try { if (mProduct.isFlag() == true) { System.out.println("消费者：消费了：" + mProduct.getName() + "价格为：" + mProduct.getPrice()); mProduct.setFlag(false); Product.CONDITION.signalAll(); } else { Product.CONDITION.await(); } } catch (InterruptedException e) { e.printStackTrace(); } finally { Product.LOCK.unlock(); } } } }1.一般线程都存在循环，通过控制其循环条件的变量来停止线程。 2.如果线程做了相应的wait()，就需要调用notify()或interrupt()来停止。 3.interrupt()会中断线程，同时清除线程临时堵塞状态。 4.interrupt()会抛出一个InterruptedException异常，相当于强制停止线程。public static void main(String[] args) { Demo demo = new Demo(); Thread thread = new Thread(demo); thread.start(); new Timer().schedule(new TimerTask() { @Override public void run() { demo.flag = false; demo.interrupt(); } }, 3000); } class Demo extends Thread { public boolean flag = true; @Override public void run() { while (flag) { System.out.println("Test"); } } }join() 1.线程如果执行join()，就意味着有新线程加入。 2.执行join()的线程必须要让步给新加入的线程，等新线程完成任务后才能继续执行。 yield() 表示当前线程对象提示调度器自己愿意让出CPU资源，但是调度器可以自由忽略该提示。isDaemon()：判断一个线程是否为守护线程。 setDaemon(boolean on)：设置一个线程为守护线程。 注意 1.守护线程依存于主线程，主线程消亡，守护线程消亡。 2.在一个进程中如果只剩下了守护线程，那么守护线程也会死亡。 3.线程默认都不是守护线程。青春短暂，我_在路上
文章来源: 线程，安全，通信