java多线程基础（一）

悠悠 2022-07-14 13:14 312阅读 0赞

java基础之多线程

1、线程生命周期

Center

2、线程的创建有两种方式

（1）继承Thread类：

  1. /*
  2.  * 创建一个子线程，完成1-100之间自然数的输出。同样的，主线程执行同样的操作。
  3.  * 创建多线程的第一种方式：继承Thread类。
  4.  */
  5. public class TestThread {
  6.     public static void main(String[] args) {
  7.         //3\创建一个子类对象
  8.         SubThread subThread1 = new SubThread();
  9.         SubThread subThread2 = new SubThread();
  10.         //4\调用线程的start（）方法：启动此线程，调用线程的run（）方法。
  11.         //一个线程只能执行一次start（）
  12.         subThread1.start();
  13.         subThread2.start();
  14.         for(int i =1;i<10000;i++){
  15.             System.out.println(Thread.currentThread().getName()+":"+i);
  16.         }
  17.     }
  18. }
  19. //1、继承Thread类
  20. class SubThread extends Thread{
  21.     //2、重写run方法，方法类内实现此子线程压迫完成的功能
  22.     public void run(){
  23.         for(int i =1;i<10000;i++){
  24.             System.out.println(Thread.currentThread().getName()+":"+i);
  25.         }
  26.     }
  27. }
  29. /*
  30.  * Thread的chnagyong fangfa 
  31.  * 1、start（）：启动线程并执行相应的run方法
  32.  * 2、run（）：子线程要执行的方法，放入run（）方法中
  33.  * 3、currentThread()：静态的，调取当前的线程
  34.  * 4、getName():获取此线程的名字
  35.  * 5、setName（）：设置此线程的名字
  36.  * 6、yield（）：调用此方法的线程释放当钱CPU的执行权。
  37.  * 7、join（）：在A线程中调用B线程的join（）方法，表示，当执行到此方法，A线程停止执行，直至Ｂ线程执行完毕，Ａ线程再接着执行。
  38.  * ８、isAlive（）：判断当前线程是否还存活。
  39.  * 9、sleep（long l）：显示的让此线程睡眠l毫秒。
  40.  * 10、线程间通信：wait（）、notify（）、notifyAll（）
  41.  */
  42. public class TestThread1 {
  44.     public static void main(String[] args) throws InterruptedException {
  45.         //3\创建一个子类对象
  46.         SubThread1 subThread1 = new SubThread1();
  47.         SubThread1 subThread2 = new SubThread1();
  48.         //4\调用线程的start（）方法：启动此线程，调用线程的run（）方法。
  49.         //一个线程只能执行一次start（）
  50.         subThread1.setName("嘿嘿");
  51.         subThread1.start();
  52.         subThread1.setPriority(Thread.MAX_PRIORITY);
  53.         subThread2.start();
  54.         Thread.currentThread().setName("主线程");
  55.         for(int i =1;i<10000;i++){
  56.             //Thread.currentThread().sleep(1000);
  57.             System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+"---"+i);
  58.             /*if(i%10==0){
  59.                 Thread.currentThread().yield();
  60.             }*/
  61.             if(i==20){
  62.                 subThread1.join();
  63.             }
  64.         }
  65.     }
  66. }
  67. //1、继承Thread类
  68. class SubThread1 extends Thread{
  69.     //2、重写run方法，方法类内实现此子线程要完成的功能
  70.     public void run(){
  71.         for(int i =1;i<10000;i++){
  72.             System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+"---"+i);
  73.         }
  74.     }
  75. }

（2）实现Runnable接口

  1. /*
  2.  * 创建线程的第二种方法：通过实现Runnable 接口来实现
  3.  * 1、创建一个实现了Runable接口的类
  4.  * 2、实现接口的抽象方法
  5.  * 3、创建一个Runnable接口实现类的对象
  6.  * 4、对象作为形参传递给Thread类的构造器中，创建Thread对象，此对象即为一个线程
  7.  * 5、调用Thread类对象的start（）方法。
  8.  * 
  9.  * 对比一下继承和实现的方式
  10.  * 1、联系：都实现了Runnable接口。（继承中的THread类，底层也是实现了Runnable接口）
  11.  * 2、哪种方式比较好？实现的方式优于继承的方式》
  12.  * （1）实现的方式避免了java中单继承的局限性（因为一个类继承了Thread之后，就不能再继承其他类了）。
  13.  * （2）比如在售票例子中，多线程操作同一份数据，更适合使用实现的方式。
  14.  */
  15. class PrintNum implements Runnable{
  16.     @Override
  17.     public void run() {
  18.         for(int i = 0 ; i<=100 ; i++){
  19.             if(i%2 == 0){
  20.                 System.out.println(Thread.currentThread().getName() +"---"+ i);
  21.             }
  22.         }
  23.     }    
  24. }
  25. public class TestRunnable{
  26.     public static void main(String[] args) {
  27.         PrintNum p = new PrintNum();
  28.         //要想启动一个多线程，必须调用start（）方法。
  29.         Thread t1 = new Thread(p);
  30.         t1.start();//启动线程执行Thread对象生成时，构造器形参的对象的run方法。
  31.         //再创建一个线程
  32.         Thread t2 = new Thread(p);
  33.         t2.start();
  34.     }
  35. }

3、线程间同步问题

  1. /*
  2.  * 此程序存在线程的安全问题，打印车票时，会出现重票和错票的问题。
  3.  */
  4. public class TestWindow1 {
  5.     public static void main(String[] args) {        
  6.         Window1 window = new Window1();
  7.         Thread t1 = new Thread(window);
  8.         Thread t2 = new Thread(window);
  9.         Thread t3 = new Thread(window);
  10.         t1.setName("窗口1");
  11.         t2.setName("窗口2");
  12.         t3.setName("窗口3");
  13.         t1.start();
  14.         t2.start();
  15.         t3.start();
  16.     }
  17. }
  18. class Window1 implements Runnable {
  19.     int sum = 100;
  20.     @Override
  21.     public void run() {
  22.         while(true){
  23.             if(sum> 0){
  24.                 try {
  25.                     Thread.currentThread().sleep(10);
  26.                 } catch (InterruptedException e) {
  27.                     // TODO Auto-generated catch block
  28.                     e.printStackTrace();
  29.                 }
  30.                 System.out.println(Thread.currentThread().getName()+"----"+sum);
  31.                 sum--;
  32.             }else if(sum == 0){
  33.                 System.out.println("这是最后一张票");
  34.                 sum--;
  35.             }else {
  36.                 break;
  37.             }
  38.         }    
  39.     }    
  40. }

分别解决多线程继承和实现方式出现的问题：

（1）同步代码块

  1. public class TestWindow3 {
  2.     public static void main(String[] args) {
  3.         Window3 w1 = new Window3();
  4.         Window3 w2 = new Window3();
  5.         Window3 w3 = new Window3();
  6.         w1.setName("窗口1");
  7.         w2.setName("窗口2");
  8.         w3.setName("窗口3");
  9.         w1.start();
  10.         w2.start();
  11.         w3.start();
  12.     }
  13. }
  14. class Window3 extends Thread{
  15.     public static int sum = 100;
  16.     static Object obj = new Object();
  17.     public void run(){
  18.         while(true){
  19.             synchronized (obj) {//在本题中，this表示w1、w2、w3。
  20.                 if (sum > 0) {
  21.                     try {
  22.                         Thread.currentThread().sleep(10);
  23.                     } catch (InterruptedException e) {
  24.                         // TODO Auto-generated catch block
  25.                         e.printStackTrace();
  26.                     }
  27.                     System.out.println(Thread.currentThread().getName()
  28.                             + "----" + sum);
  29.                     sum--;
  30.                 }else {
  31.                     break;
  32.                 }
  33.             }
  34.         }
  35.     }
  36. }
  38. /*
  39.  * 此程序存在线程的安全问题，打印车票时，会出现重票和错票的问题。
  40.  * 1、存在的原因是什么？
  41.  *  由于一个线程在操作共享数据未执行完的情况下，另外的数据参与进来，导致共享数据存在安全问题。
  42.  * 
  43.  * 2、如何解决线程的安全问题？
  44.  *  必须让一个操作共享数据完毕以后，其他线程才有机会参与共享数据的操作。
  45.  * 
  46.  * 3、java如何实现线程的安全：线程的同步机制
  47.  *     方式一：同步代码块
  48.  *     synchronized(对象(同步监视器)){
  49.  *     //需要被同步的代码块（即为操作共享数据的代码）
  50.  * }
  51.  * （1）共享数据：多个线程共同操作的同一个数据或者变量
  52.  * （2）同步监视器（锁）：由一个对象来充当。哪个线程获取此监视器，谁就能执行大括号里被同步的代码。
  53.  *  注：要求所有的线程必须使用同一把安全锁，才能实现同步。
  54.  *  在实现的方式中可以使用this作为同步锁，但是在继承的方式要慎用。
  55.  *     方式二：同步方法
  56.  *     synchronized 还可以放在方法的声明中，表示整个方法为同步方法
  57.  * 例如：public synchronized void show(String name){
  58.  *     ....
  59.  * }
  60.  *     注： 将操作共享数据的方法声明成synchronized 。即此方法为同步方法，能够保证当其中一个线程执行此方法时，其他线程在外等待，
  61.  *  直至此线程执行完此方法。
  62.  *   》同步方法的锁：就是当前对象this。
  63.  */
  64. public class TestWindow2 {
  65.     public static void main(String[] args) {        
  66.         Window2 window = new Window2();
  67.         Thread t1 = new Thread(window);
  68.         Thread t2 = new Thread(window);
  69.         Thread t3 = new Thread(window);
  70.         t1.setName("窗口1");
  71.         t2.setName("窗口2");
  72.         t3.setName("窗口3");
  73.         t1.start();
  74.         t2.start();
  75.         t3.start();
  76.     }
  77. }
  78. class Window2 implements Runnable {
  79.     int sum = 100; //共享数据
  80.     //Animal obj = new Animal();
  81.     @Override
  82.     public void run() {
  83.         while(true){
  84.             synchronized (this) {//在本问题中，this表示当前对象，本题中表示window，只有一个，所以此处可以使用this
  85.                 if(sum> 0){
  86.                     try {
  87.                         Thread.currentThread().sleep(10);
  88.                     } catch (InterruptedException e) {
  89.                         // TODO Auto-generated catch block
  90.                         e.printStackTrace();
  91.                     }
  92.                     System.out.println(Thread.currentThread().getName()+"----"+sum);
  93.                     sum--;
  94.                 }else if(sum == 0){
  95.                     System.out.println("这是最后一张票");
  96.                     sum--;
  97.                 }else {
  98.                     break;
  99.                 }
  100.             }
  101.         }    
  102.     }    
  103. }

注：如果synchronized (this) {}包含住了while（true）这个代码块，那么控制台就会出现，只有一个线程在执行售票业务的情况。

（2）同步代码方法

注意：在继承Thread类方法中，不能使用synchronized方法，因为锁对象不是唯一的，所以依旧会出现同步问题。 

  1. /*
  2.  * 此程序存在线程的安全问题，打印车票时，会出现重票和错票的问题。
  3.  */
  4. public class TestWindow4 {
  5.     public static void main(String[] args) {        
  6.         Window4 window = new Window4();
  7.         Thread t1 = new Thread(window);
  8.         Thread t2 = new Thread(window);
  9.         Thread t3 = new Thread(window);
  10.         t1.setName("窗口1");
  11.         t2.setName("窗口2");
  12.         t3.setName("窗口3");
  13.         t1.start();
  14.         t2.start();
  15.         t3.start();
  16.     }
  17. }
  18. class Window4 implements Runnable {
  19.     int sum = 100;
  20.     @Override
  21.     public void run() {
  22.         while(true){
  23.             show();
  24.         }    
  25.     }
  26.     public synchronized void show(){
  27.             if (sum > 0) {
  28.                 try {
  29.                     Thread.currentThread().sleep(10);
  30.                 } catch (InterruptedException e) {
  31.                     // TODO Auto-generated catch block
  32.                     e.printStackTrace();
  33.                 }
  34.                 System.out.println(Thread.currentThread().getName()
  35.                         + "----" + sum);
  36.                 sum--;
  37.             } 
  38.     }
  39. }

4、单例模式（懒汉式）中关于多线程同步的解决问题

  1. /*
  2.  * 关于懒汉式的线程安全问题，使用同步机制，对于一般的方法内，使用同步代码块，可以考虑使用this作为同步锁。
  3.  * 对于静态方法，使用当前类本身充当锁
  4.  */
  5. public class TestSingleTon {
  6.     public static void main(String[] args) {
  7.         SingleTon s1 = SingleTon.getInstance();
  8.         SingleTon s2 = SingleTon.getInstance();
  9.         System.out.println(s1 == s2);
  10.     }
  11. }
  12. class SingleTon{    
  13.     private SingleTon(){}
  14.     private static  SingleTon instance = null;    
  15.     public static SingleTon getInstance(){
  16.         //加上下边这个if判断语句，程序的效率会提高不少
  17.         if(instance == null){
  18.             synchronized (SingleTon.class) {            
  19.                 if(instance == null)
  20.                     instance = new SingleTon();
  21.             }
  22.         }
  23.         return instance;
  24.     }
  25. }

5、多线程实例：实现两个人往银行账户中存钱

  1. /*
  2.  * 实现两个人往银行账户中存钱：方式一：采用继承的方法
  3.  */
  4. public class TestAccount {
  5.     public static void main(String[] args) {
  6.         Account2 account2 = new Account2();
  7.         Customer2 a1 = new Customer2(account2);
  8.         Customer2 a2 = new Customer2(account2);
  9.         a1.setName("账户1");
  10.         a2.setName("账户2");
  11.         a1.start();
  12.         a2.start();
  13.     }
  14. }
  15. class Account2{
  16.     private double balance;
  17.     public Account2(){
  19.     }
  20.     public synchronized void deposit(double amt){
  21.         this.balance += amt;
  22.         try {
  23.             Thread.currentThread().sleep(100);
  24.         } catch (InterruptedException e) {
  25.             // TODO Auto-generated catch block
  26.             e.printStackTrace();
  27.         }
  28.         System.out.println(Thread.currentThread().getName()+"操作后，"+this.balance);
  29.     }
  30. }
  31. class Customer2 extends Thread{
  32.     Account2 account;
  33.     public Customer2(Account2 account){
  34.         this.account = account;        
  35.     }
  36.     public void run(){            
  37.             for(int i = 0 ;i<3;i++){
  38.                 account.deposit(1000);
  39.             }
  40.     }
  41. }
  43. /*
  44.  * 实现两个人往银行账户中存钱：方式二：采用实现的方法
  45.  */
  46. public class TestAccount1 {
  47.     public static void main(String[] args) {
  48.         Account account = new Account();
  49.         Customer c = new Customer(account);
  50.         Thread t1 = new Thread(c);
  51.         Thread t2 = new Thread(c);
  52.         t1.start();
  53.         t2.start();        
  54.     }
  55. }
  56. class Customer implements Runnable {
  57.     private Account account = null;
  58.     public Account getAccount() {
  59.         return account;
  60.     }
  61.     public void setAccount(Account account) {
  62.         this.account = account;
  63.     }
  64.     public Customer() {
  65.         super();
  66.     }
  67.     public Customer(Account account) {
  68.         super();
  69.         this.account = account;
  70.     }
  71.     @Override
  72.     public void run() {
  73.         synchronized (this) {
  74.             for (int i = 0; i < 3; i++) {
  75.                 account.setMoney(1000);
  76.             }
  77.         }
  78.     }
  79. }
  80. class Account {
  81.     private int money = 0;
  82.     public Account() {
  83.         System.out.println("账户现有：" + money);
  84.     }
  85.     public Account(int money) {
  86.         this.money = money;
  87.         System.out.println("账户现有：" + this.money);
  88.     }
  89.     public int getMoney() {
  90.         return money;
  91.     }
  92.     public void setMoney(int money) {
  93.         this.money += money;
  94.         System.out.println(Thread.currentThread().getName() + "-----" + money);
  95.         System.out.println("账户余额是：" + this.money);
  96.     }
  97. }

6、实现线程之间的通信（使用wait（）、notify（）、notifyAll（））

  1. /*
  2.  * 线程通信:如下的三个关键字使用的话，都得在同步代码块或者同步方法中
  3.  * wait()：一旦一个线程执行到wait方法，就释放当前的锁。
  4.  * notify()：唤醒wait（）的一个线程
  5.  * notifyAll()：唤醒wait（）的所有线程
  6.  */
  7. class PrintNum implements Runnable{
  8.     int num = 0;
  9.     @Override
  10.     public void run() {
  11.         while(true){
  12.             synchronized (this) {
  13.                 notify(); //在此处加notify，意思是，第一个线程执行结束，释放锁，第二个线程进来之后，
  14.                 //首先已经获取锁了，然后再唤醒另一个线程（虽然此时唤醒，但是也只能等到第二个线程释放锁之后，第一个线程才能再次开始执行）。
  15.                 if(num <= 100){
  16.                     try {
  17.                         Thread.currentThread().sleep(10);
  18.                     } catch (InterruptedException e) {
  19.                         // TODO Auto-generated catch block
  20.                         e.printStackTrace();
  21.                     }
  22.                     System.out.println(Thread.currentThread().getName() + "-----"
  23.                             + num);
  24.                     num++;
  25.                 }
  26.                 try {
  27.                     wait();
  28.                 } catch (InterruptedException e) {
  29.                     // TODO Auto-generated catch block
  30.                     e.printStackTrace();
  31.                 }
  32.         }
  33.         }
  34.     }    
  35. }
  36. public class TestCommunication {
  37.     public static void main(String[] args) {
  38.         PrintNum printNum = new PrintNum();
  39.         Thread t1 = new Thread(printNum);
  40.         Thread t2 = new Thread(printNum);
  41.         t1.start();
  42.         t2.start();        
  43.     }
  44. }
  46. /*
  47.  * 实现两个人往银行账户中存钱：方式一：采用继承的方法
  48.  */
  49. public class TestAccount {
  50.     public static void main(String[] args) {
  51.         Account2 account2 = new Account2();
  52.         Customer2 a1 = new Customer2(account2);
  53.         Customer2 a2 = new Customer2(account2);
  54.         a1.setName("账户1");
  55.         a2.setName("账户2");
  56.         a1.start();
  57.         a2.start();
  58.     }
  59. }
  60. class Account2{
  61.     private double balance;
  62.     public Account2(){
  64.     }
  65.     public synchronized void deposit(double amt){
  66.         notify();
  67.         this.balance += amt;
  68.         try {
  69.             Thread.currentThread().sleep(100);
  70.         } catch (InterruptedException e) {
  71.             // TODO Auto-generated catch block
  72.             e.printStackTrace();
  73.         }
  74.         System.out.println(Thread.currentThread().getName()+"操作后，"+this.balance);
  75.         try {
  76.             wait();
  77.         } catch (InterruptedException e) {
  78.             // TODO Auto-generated catch block
  79.             e.printStackTrace();
  80.         }
  81.     }
  82. }
  83. class Customer2 extends Thread{
  84.     Account2 account;
  85.     public Customer2(Account2 account){
  86.         this.account = account;        
  87.     }
  88.     public void run(){            
  89.             for(int i = 0 ;i<3;i++){
  90.                 account.deposit(1000);
  91.             }
  92.     }
  93. }

7、死锁

  1. /*
  2.  * 死锁问题，处理线程同步时，容易出现这个问题
  3.  * 不同的线程分别占用对方的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
  4.  * 如下例：第一个线程在执行的时候，首先握住sb1这个锁,要想释放sb1锁，必须先要执行完里面握住sb2锁的操作执行完毕才可以。但是在这个过程中，另一个线程可能在第一个线程拿到sb2锁，并且第二个线程也需要调用sb1锁才能释放sb2锁，这样就会导致双方都握住对方的锁，但是都不能执行，从而造成死锁。
  5.  */
  6. public class TestDeadLock {
  7.     static StringBuffer sb1 = new StringBuffer();
  8.     static StringBuffer sb2 = new StringBuffer();
  9.     public static void main(String[] args) {
  10.         new Thread(){
  11.             public void run(){
  12.                 synchronized (sb1) {
  13.                     try {
  14.                         Thread.currentThread().sleep(100);
  15.                     } catch (InterruptedException e) {
  16.                         // TODO Auto-generated catch block
  17.                         e.printStackTrace();
  18.                     }
  19.                     sb1.append("A");
  20.                     synchronized (sb2) {
  21.                         sb2.append("B");
  22.                     }
  23.                 }
  24.                 System.out.println(sb1);
  25.                 System.out.println(sb2);
  26.             }
  27.         }.start();        
  28.         new Thread(){
  29.             public void run(){
  30.                 synchronized (sb2) {
  31.                     try {
  32.                         Thread.currentThread().sleep(100);
  33.                     } catch (InterruptedException e) {
  34.                         // TODO Auto-generated catch block
  35.                         e.printStackTrace();
  36.                     }
  37.                     sb2.append("C");
  38.                     synchronized (sb1) {
  39.                         sb1.append("D");
  40.                     }
  41.                 }
  42.                 System.out.println(sb1);
  43.                 System.out.println(sb2);
  44.             }            
  45.         }.start();    
  46.     }
  47. }

8、生产者消费者例子

  1. /*
  2.  * 生产者消费者模式
  3.  * 1、是否涉及多线程；生产者、消费者
  4.  * 2、是否涉及到共享数据？有！
  5.  * 3、此共享数据是谁？即为产品数量
  6.  * 4、是否涉及到线程的通信？存在着生产者与消费者的通信
  7.  */
  8. class Clerk{
  9.     int produtor;
  10.     public synchronized void addProdutor(){
  12.         if(produtor>=20){
  13.             try {
  14.                 wait();
  15.             } catch (InterruptedException e) {
  16.                 // TODO Auto-generated catch block
  17.                 e.printStackTrace();
  18.             }
  19.         }else {
  20.             produtor++;
  21.             System.out.println(Thread.currentThread().getName()+"生产了第："+produtor+"个产品");
  22.             notifyAll();
  23.         }
  24.     }
  25.     public synchronized void consumeProductor(){
  26.         if(produtor<=0){
  27.             try {
  28.                 wait();
  29.             } catch (InterruptedException e) {
  30.                 // TODO Auto-generated catch block
  31.                 e.printStackTrace();
  32.             }
  33.         }else {
  34.             produtor--;
  35.             System.out.println(Thread.currentThread().getName()+"消费了第："+produtor+"个产品");
  36.             notifyAll();
  37.         }
  38.     }
  39. }
  40. class Producer implements Runnable{
  41.     Clerk clerk;
  42.     public  Producer(Clerk clerk) {
  43.         this.clerk = clerk;
  44.     }
  45.     @Override
  46.     public void run() {
  47.         System.out.println("生产者开始生产产品");
  48.         while(true){
  49.             try {
  50.                 Thread.currentThread().sleep(100);
  51.             } catch (InterruptedException e) {
  52.                 // TODO Auto-generated catch block
  53.                 e.printStackTrace();
  54.             }
  55.             clerk.addProdutor();
  56.         }
  57.     }    
  58. }
  59. class Consumer implements Runnable{
  60.     Clerk clerk;
  61.     public  Consumer(Clerk clerk) {
  62.         this.clerk = clerk;
  63.     }
  64.     @Override
  65.     public void run() {
  66.         while(true){
  67.             try {
  68.                 Thread.currentThread().sleep(100);
  69.             } catch (InterruptedException e) {
  70.                 // TODO Auto-generated catch block
  71.                 e.printStackTrace();
  72.             }
  73.             clerk.consumeProductor();
  74.         }
  75.     }    
  76. }
  77. public class TestProduceAndCutomer {
  78.     public static void main(String[] args) {
  79.         Clerk clerk = new Clerk();
  80.         Producer p = new Producer(clerk);
  81.         Consumer c = new Consumer(clerk);
  82.         Thread t1 = new Thread(p);
  83.         Thread t2 = new Thread(c);
  84.         Thread t3 = new Thread(p);
  85.         t1.start();
  86.         t2.start();
  87.         t3.start();
  88.     }
  89. }

发表评论

表情：
评论列表 （有 0 条评论，312人围观）

还没有评论，来说两句吧...

相关阅读

    相关 【一】多线程 —— 基础概念

    > 一、进程、线程与协程 进程 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网

    朱雀朱雀/ 0 赞/ 288 阅读

    相关 (一) 多线程基础

    1.进程和线程区别 多进程：在操作系统中能同时运行多个任务(程序)。如电脑： 微信和网易云音乐同时运行 多线程：在同一应用程序中有多个顺序流在执行。如网易云音乐：音乐

    Love The Way You LieLove The Way You Lie/ 0 赞/ 385 阅读

    相关 java多线程之基础（一）

    线程和进程： 进程：资源（cpu,内存，磁盘）分配的最小单位 线程：归属于某个进程，cpu调度的最小单元（栈、程序计数器），堆 cpu轮转机制（RR调度）：主要用于分

    以你之姓@以你之姓@/ 0 赞/ 439 阅读