1.理清概念 并行与并发：
*并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
*并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。
2.线程创建
* 继承thread类创建多线程
public class Example01 {
public static void main(String[] args) {
MyThread myThread = new MyThread(); //创建线程 MyThread 的线程对象
myThread.start(); //开启线程
while(true){
System.out.println("main 方法在运行");
}
}
}
class MyThread extends Thread{
public void run(){
while (true){
System.out.println("MyThread 类的 run()方法在运行");
}
}
}
* 实现Runnable接口创建线程
public class Example01 {
public static void main(String[] args) {
MyThread myThread = new MyThread(); //创建线程 MyThread 的线程对象
Thread thread = new Thread(myThread); //创建线程对象
thread.start(); //开启线程，执行线程中的run()方法
while(true){
System.out.println("main 方法在运行");
}
}
}
class MyThread implements Runnable{
public void run(){
while (true){
System.out.println("MyThread 类的 run()方法在运行");
}
}
}
* 两种实现多线程方式的对比分析，实现Runnable接口相对于继承Thread类有如下显著的好处
1.可以避免由于java的单继承带来的局限。java不支持多继承(子类不能有多个父类)，其他类的子类不能用继承Thread类的方式，只能采用实现Runnable接口的方式
2.适合多个相同程序代码的线程去处理同一个资源的情况，把线程同程序代码、数据有效的分离
* 后台进程
--如果某个线程对象在启动之前调用了setDaemon(true)语句，这个线程就变成一个后台进程
--当前台线程结束后，JVM会通知后台线程
--进程中只有后台线程运行时，进程会结束
3.线程的调度
* 线程的优先级
--static int MAX_PRIORITY 表示线程的最高优先级 相当于值10
--static int MIN_PRIORITY 表示线程的最低优先级 相当于值1
--static int NORM_PRIORITY 表示线程的普通优先级 相当于值5
* 线程休眠
--Thread.sleep()
* 线程让步
--Thread.yield()
* 线程插队
--join()
4.多线程同步
* 线程安全
--多个线程同时去访问同一个资源时，易引发安全问题。
*同步代码块
class Ticket1 implements Runnable{
private int tickets = 10; //定义变量 赋值
Object lock = new Object(); //定义任意一个对象，用作同步代码块的锁
public void run(){
while (true){
synchronized(lock){ //定义同步代码块
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(tickets >0){
System.out.println(Thread.currentThread().getName()+"---卖出的票---"+tickets--);
}else{
break;
}
}
}
}
}
public class Example01 {
public static void main(String[] args) {
Ticket1 ticket = new Ticket1(); //创建 Ticket1 对象
//创建并开启四个线程
new Thread(ticket,"线程1").start();
new Thread(ticket,"线程2").start();
new Thread(ticket,"线程3").start();
new Thread(ticket,"线程4").start();
}
}
*同步方法
class Ticket1 implements Runnable{
private int tickets = 10; //定义变量 赋值
public void run(){
while (true){
saleTicket();
if(tickets <=0){
break;
}
}
}
//定义一个同步方法saleTicket()
private synchronized void saleTicket(){
if(tickets > 0){
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"---卖出的票---"+tickets--);
}
}
}
public class Example01 {
public static void main(String[] args) {
Ticket1 ticket = new Ticket1(); //创建 Ticket1 对象
//创建并开启四个线程
new Thread(ticket,"线程1").start();
new Thread(ticket,"线程2").start();
new Thread(ticket,"线程3").start();
new Thread(ticket,"线程4").start();
}
}
*锁死问题
5.多线程通信
*问题引入：假设有两个线程同时去操作同一个存储空间，其中一个线程负责向存储空间中存入数据，另一个线程负责取出数据。
--数据存储类
public class Storage {
//数据存储数组
private int[] cells = new int[10];
//inPos 表示存入时数组下标，outPos表示取出时数组下标
private int inPos,outPos;
//定义一个put()方法向数组中存入数据
public void put(int num){
cells[inPos] = num;
System.out.println("在cells["+inPos+"]中放入数据--"+cells[inPos]);
inPos++;
if(inPos == cells.length)
inPos = 0; //当inPos为数组长度时 将其置为0
}
//定义一个get()方法从数组中取出数据
public void get(){
int data = cells[outPos];
System.out.println("在cells["+outPos+"]中取出数据--"+data);
outPos++;
if(outPos == cells.length)
outPos = 0; //当outPos为数组长度时 将其置为0
}
}
--数据存取类
public class Input implements Runnable {
private Storage st;
private int num;
Input (Storage st){ //通过构造方法接收一个Storage对象
this.st= st;
}
@Override
public void run() {
while(true){
st.put(num++); //将num存入数组，每次存入后num自增
}
}
}
public class Output implements Runnable {
private Storage st;
Output(Storage st){ //通过构造方法接收一个Storage对象
this.st = st;
}
@Override
public void run() {
while(true){
st.get();
}
}
}
--创建线程
public class ExampleTest02 {
public static void main(String[] args) {
Storage st = new Storage(); //创建数据存储对象
Input input = new Input(st); //创建Input对象传入Storage对象
Output output=new Output(st); //创建Output对象传入Storage对象
new Thread(input).start(); //开启新线程
new Thread(output).start(); //开启新线程
}
}
* 问题解决：测试发现上述存取进程是随机的，未按照顺序轮流执行。如需按照一定顺序轮流执行，此时需要让进程间进行通信
--在Object类中提供了wait(),notify(),notifyAll()方法用于解决线程间的通信问题，因为Java中的所有类都是Object类的子类或间接子类，因此任何类的实例对象都可以直接使用这些方法。
--void wait() 使当前线程放弃同步锁并进入等待，直到其他线程进入此同步锁，并调用notify()或notifyAll()方法唤醒该线程为止
--void notify() 唤醒此同步锁上等待的第一个调用wait()方法的线程
--void notifyAll() 唤醒此同步锁上调用wait()方法的所有线程
public class Storage {
private int[] cells = new int[10]; //数据存储数组
private int inPos,outPos; //inPos 表示存入时数组下标，outPos表示取出时数组下标
private int count; //存入或取出数据的数量
//定义一个put()方法向数组中存入数据
public synchronized void put(int num){
//存入数据如果等于cells的长度，此线程等待
while(count == cells.length){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
cells[inPos] = num;
System.out.println("在cells["+inPos+"]中放入数据--"+cells[inPos]);
inPos++;
if(inPos == cells.length)
inPos = 0; //当inPos为数组长度时 将其置为0
count++;
this.notify();
}
//定义一个get()方法从数组中取出数据
public synchronized void get(){
while(count == 0){ //如果count为0 此线程等待
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
int data = cells[outPos];
System.out.println("在cells["+outPos+"]中取出数据:"+data);
cells[outPos] = 0;
outPos++;
if(outPos == cells.length)
outPos = 0; //当outPos为数组长度时 将其置为0
count--;
this.notify();
}
}
注意：如果wait(),notify(),notifyAll()方法调用者不是同步锁对象，JVM会抛出 java.lang.IllegalMonitorStateException