多线程最精简理解

*多线程*

*一：线程和进程的关系*

一个应用是由一个或多个进程组成，一个进程是由多个线程组成

*二：线程的状态转换*

*大体分四步：*

*初始状态----->可运行---->运行中—>结束*

*可运行---->运行中又分为3种；*

1. *运行中—>阻塞状态—>可运行*

2. *等待队列—>锁池状态—>可运行*

3. *锁池状态—>可运行*

*如图：*

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kK6zGYIg-1583323100354)(file:///C:\Users\常光华\AppData\Local\Temp\ksohtml12856\wps1.jpg)]

*三：如何创建线程*

1. *第一种继承Thread类创建线程（一般不常用多用接口创建线程）*

*第一步：*

*创建一个实体类继承Thread类（extends Thread）*

*附源码：*

public class ThreadA extends Thread {

int m = 100;

// 重写 run 方法 在其中写一个for循环遍历

@Override

public void run() {

for (int i=0;i<m;i++){

System.out.println(“i:”+i);

}

}

}

*第二步创建一个测试类进行测试：*

public class Test1 {

public static void main(String[] args) {

//创建一个Thread对象

ThreadA threadA = new ThreadA();

//线程A处于就绪状态,只能调用一次start方法

// 启动线程

threadA.start(); //启动线程

}

}

2. *第二种实现接口Runnable创建线程（一般常用接口创建线程）*

*第一步：*

*创建一个实力类实现Runnable接口*

*附源码：*

public class ThreadB implements Runnable {

int m = 100;

// 实现 run 方法

@Override

public void run() {

for (int j=0;j<m;j++){

System.out.println(“j:”+j);

}

}

}

*第二步创建一个测试类进行测试：*

public class Test1 {

public static void main(String[] args) {

// 启动线程

Thread threadB = new Thread(new ThreadB());

threadB.start();

}

*四 ：线程常见方法*

1. *Thread.join(); 可以先让某一个线程执行完毕在执行下面的代码*

2. *Thread.sleep(); sleep是********Thread********类的静态方法，********sleep********不会释放对象锁 可以使其暂停自己设置的时间*

3. *Thread.start(); 启动线程*

*4.Thread.setPriority(Thread.NORM_PRIORITY) 线程的优先级*

*// 线程的优先级 为了提交 cpu 分给 线程 时间分片 的一个概率 （cpu 执行这个线程的概率 更大了，不一定执行）*

​ *// 线程默认优先级 5 Thread.NORM_PRIORITY*

​ *// 最高优先级 10 Thread.MAX_PRIORITY*

​ *// 最低优先级 1 Thread.MIN_PRIORITY*

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qfntXTNy-1583323100355)(file:///C:\Users\常光华\AppData\Local\Temp\ksohtml12856\wps2.jpg)]

*4线程的同步 ：*

*例写银行账号支出和收入*

*第一步：创建一个工具类Account*

*声明一个变量工资*

package com.aaa.demol2;

/****
** ***** *@AUTHOR*** （常光华）**
** ***** *@date*** 2020-03-04 11:13**
** /*
**public class Account {

//账户余额
private float balance=100.0f;
//创建一个工资方法

//synchronized是锁当前对象当一个方法里的线程，当前线程全部执行完了才执行下一个进程 还可以用方法体的形式写

/*public void withDrawMoney(float money){

​ //对象锁 使用 synchronized 代码块的 相对来说 代码块性能更好

​ synchronized (this){

​ balance = balance - money;

​ }

*/

//先获取一个工资的get方法
public synchronized float getBalance(){
return balance;
}
/****
** ***** 存钱**
** ***** *@param*** money**
** /*
** public synchronized void saveMoney(float money){
balance=balance+money;
}

/****
** ***** 取钱**
** ***** *@param*** money**
** /*
** public void drawMoney(float money){
balance=balance-money;
}

// balance = balance - money; 1000 - 10
// cpu 执行 temp = balance- money; 1000 - 10 = 990
// balance = temp; balance = 990

// 多个线程 访问必须持有 当前 类的锁，非常重量级，效率比较低
public synchronized static void test(){
System.out.println("hello ");
}

}

*第二步：*

*创建一个实现类*

package com.aaa.demol2;

/****
** ***** *@AUTHOR*** （常光华）**
** ***** *@date*** 2020-03-04 11:34**
** /*
**public class AccountTest {
public static void main(String[] args) {
//m遍历的次数
int m=1000;
//创建一个对象
Account account = new Account();

​ // new Runnable() 匿名内部类
// Runnable runnable = new Runnable() {
// @Override
// public void run() {
// }
// };
​ //等价于下面

// new Runnable() 匿名内部类
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i <m ; i++) {
account.saveMoney(10);
}
}
});
//启动运行
thread1.start();

Thread thread2 = new Thread(new Runnable() {
  @Override
  public void run() {
    for (int i = 0; i <m ; i++) {
      account.drawMoney(10);
    }
  }
});
thread2.start();




try {
  //等待其他线程执行完毕 获取账户余额 1000*10+100=10100
  Thread.**sleep**(1000);

//调用get方法获取工资
System.out.println(“账户余额”+account.getBalance());
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}

<m ; i++) {
account.drawMoney(10);
}
}
});
thread2.start();

try {
  //等待其他线程执行完毕 获取账户余额 1000*10+100=10100
  Thread.**sleep**(1000);

//调用get方法获取工资
System.out.println(“账户余额”+account.getBalance());
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}