多线程总结一

最新推荐文章于 2024-07-12 16:39:39 发布
最新推荐文章于 2024-07-12 16:39:39 发布
阅读量1.6k 收藏 8
点赞数
文章标签： java多线程高级知识整理一
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24186017/article/details/79067614
版权

总结：
多线程创建的4中方式： Thread Runnable Callable 线程池

加锁的方式： synchronized  
                  ReentrantLock    lock unlock

生产者消费者模式，线程的等待唤醒通知机制： (用while防止虚假唤醒)
synchronized  wait() notifyall()
ReentrantLock  Condition的await（） 和signalAll()

线程的锁机制：  
                      static synchronized 和 synchronized
                       所有的 静态同步方法用的是同一把锁，类对象本身。
             所有静态同步方法用的是同一把锁，实例对象本身
线程轮询的时候定制顺序访问：
          condition1.await()   condition2.signal()
读写锁：ReentrantReadWriteLock 
       ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
           rw .writeLock().lock();
           rw .writeLock().unlock();
          rw .readLock().lock();
           rw .readLock().lock();

Lock的模板：  
lock.lock();
          try {
            //判断、干活、唤醒
          } finally {
              lock.unlock();
          }

 线程池：  利用Executors得到ExecutorService
                      Executors . newFixedThreadPool(5) //5个线程的线程池
                Executors.newSingleThreadExecutor()//一个线程
                Executors. newCachedThreadPool ()//随机线程
                Executors. newScheduledThreadPool (5)//5个线程，有时间间隔

多线程之间按顺序调用 A -> B -> C
 *AA打印5次，BB打印10次，CC打印15次
 *接着
 *AA打印5次，BB打印10次，CC打印15次
 * ......来10轮
分析：三个AA,BB,CC线程都进行10次循环，线程i=1先抢到，number=1先进入AA线程的方法中，当AA循环打印了5次后，利用condition2.signal()唤醒了condition2.await()的



1.售票问题：
class Tikect {
      // 高内聚，低耦合
      int number = 30;
      ReentrantLock lock = new ReentrantLock();
      public void sale() {
           // 票具有的方法
           lock .lock();
           try {
               if ( number >0){
                   
                   System. out .println(Thread. currentThread ().getName() + "\t还剩" + number + "\t卖出第" +(-- number ));
              }
          } catch (Exception e ) {
          } finally {
               lock .unlock();
          }
     }
}
/**
 *
 * 三个售票员 三个窗口 卖30张票 多线程问题
 *
 * 线程 解决 资源类 高内聚，低耦合
 *
 *
 *
 * @author 77585211
 *
 */
public class Test1 {
      public static void main(String[] args ) {
          Tikect tikect = new Tikect();
           new Thread( new Runnable() {
               @Override
               public void run() {
               for ( int i = 0; i < 50; i ++) {
                   
                 tikect .sale();
              }
              }
          }, "售票員A" ).start();
           new Thread( new Runnable() {
               @Override
               public void run() {
                     for ( int i = 0; i < 50; i ++) {
                             
                      tikect .sale();
                   }
              }
          }, "售票員B" ).start();
           new Thread( new Runnable() {
               @Override
               public void run() {
                     for ( int i = 0; i < 50; i ++) {
                             
                      tikect .sale();
                   }
              }
          }, "售票員C" ).start();
     }
}

总结1.：ReentrantLock比Synconized好的地方是，Syconized是锁掉整个方法，而ReentrantLock是锁住几行。
lock.lock()方法要放在try..catch之前

2.创建多线程的方法之一 ： 实现Callable接口

/**
 * 根据 Callable <V> 接口创建多线程 
 * @author 77585211
 *
 *
 *当有一件事情特别浪费时间，可以用FutureTask,用于异步获取结果
 *线程  操作  资料类
 *高内聚 低耦合
 *
 */
public class Test2 {
      public static void main(String[] args ) throws InterruptedException, ExecutionException{
           //主方法中不写逻辑
          FutureTask<Integer>  ft = new FutureTask<Integer>( new Call());
           new Thread( ft , "AA" ).start();
          System. out .println( "*********main主方法1" );
           int result = ft .get();
          System. out .println( "调用FutureTask中的方法：" + result );
     }
}
class Call implements Callable<Integer>{
           @Override
           public Integer call() throws Exception {
              
              System. out .println( "*****call()调用了" );
              
              Thread. sleep (2000);
              
               return 123;
          }
          
     }
总结2: FutureTask<V>

1.多用于耗时的计算，主线程执行完之后，再去取结果
2.只计算一次
3.仅在计算完后才能得到结果，如果计算尚未完成就取数据，将会线程堵塞状态


3.多线程实现交替（一个减，一个加）
题目：现在有两个线程，可以操作初始值为0的数，实现一个线程对该变量+1，一个线程对该变量-1， 实现交替5轮

package TreadTest1;
/**
 * 现在有两个线程，可以操作初始值为0的数，实现一个线程对该变量+1，一个线程对该变量 - 1， 实现交替5轮
 *
 * @author 77585211 线程 操作 资料类
 */
class MyThread01 {
      public int number = 0;
      // 两个方法， +1 ，-1
      public synchronized void increment() throws InterruptedException {
           // 判断
           // if(number!=0)会出现虚假判断
           while ( number != 0) {
               this .wait();
          }
           // 干活
          ++ number ;
          System. out .println(Thread. currentThread ().getName() + "\t" + number );
           // 释放
           this .notifyAll();
     }
      public synchronized void decrement() throws InterruptedException {
           // 判断
           // if(number!=0)会出现虚假判断
           while ( number == 0) {
               this .wait();
          }
           // 干活
          -- number ;
          System. out .println(Thread. currentThread ().getName() + "\t" + number );
           // 释放
           this .notifyAll();
     }
}
public class Test4 {
      public static void main(String[] args ){
          MyThread01 myThread01 = new MyThread01();
           new Thread(()->{
              
               try {
                    for ( int i = 1; i <=5; i ++) {
                         myThread01 .increment();
                        
                   }
                   
              } catch (Exception e ) {
                   
                    e .printStackTrace();
              }
              
          }, "AA" ).start();
          
           new Thread(()->{
              
               try {
                    for ( int i = 1; i <=5; i ++) {
                         myThread01 .decrement();
                        
                   }
              } catch (Exception e ) {
                   
                    e .printStackTrace();
              }
              
              
          }, "BB" ).start();
       new Thread(()->{
              
               try {
                    for ( int i = 1; i <=5; i ++) {
                         myThread01 .increment();
                        
                   }
              } catch (Exception e ) {
                   
                    e .printStackTrace();
              }
              
              
          }, "CC" ).start();
       new Thread(()->{
              
               try {
                    for ( int i = 1; i <=5; i ++) {
                         myThread01 .decrement();
                        
                   }
              } catch (Exception e ) {
                   
                    e .printStackTrace();
              }
              
              
          }, "DD" ).start();
          
     }
}
优化： 使用JUC 的锁 Condition接口


package TreadTest1;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 现在有两个线程，可以操作初始值为0的数，实现一个线程对该变量+1，一个线程对该变量 - 1， 实现交替5轮 使用ReentrantLock的方法
 *
 * @author 77585211
 *
 */
class MyThread02 {
      private int number = 0;
      private ReentrantLock lock = new ReentrantLock();
      private Condition condition = lock .newCondition();
      public void increment() throws InterruptedException {
           lock .lock(); // 线程一个一个的进
           try {
               while ( number != 0) {
                    condition .await();
              }
               // 干活
              ++ number ;
               System. out .println(Thread. currentThread ().getName() + "\t" + number );
               // 唤醒
               condition .signalAll();
          } finally {
               lock .unlock();
          }
     }
      public void decrement() throws InterruptedException {
           lock .lock(); // 线程一个一个的进
           try {
               while ( number == 0) {
                    condition .await();
              }
               // 干活
              -- number ;
               System. out .println(Thread. currentThread ().getName() + "\t" + number );
               // 唤醒
               condition .signalAll();
          } finally {
               lock .unlock();
          }
     }
     
     
     
}
public class Test5 {
      public static void main(String[] args ){
          MyThread02 thread02 = new MyThread02();
           new Thread(()->{
              
               try {
                    for ( int i = 1; i <=10; i ++) {
                        
                         thread02 .increment();
                   }
              } catch (Exception e ) {
                   
                    e .printStackTrace();
              }
              
              
          }, "AA" ).start();
          new Thread(()->{
              
               try {
                    for ( int i = 1; i <=10; i ++) {
                        
                         thread02 .decrement();
                   }
              } catch (Exception e ) {
                   
                    e .printStackTrace();
              }
              
              
          }, "BB" ).start();
          new Thread(()->{
              
               try {
                    for ( int i = 1; i <=10; i ++) {
                        
                         thread02 .increment();
                   }
              } catch (Exception e ) {
                   
                    e .printStackTrace();
              }
              
              
          }, "CC" ).start();
          
          new Thread(()->{
              
               try {
                    for ( int i = 1; i <=10; i ++) {
                        
                         thread02 .decrement();
                   }
              } catch (Exception e ) {
                   
                    e .printStackTrace();
              }
              
              
          }, "DD" ).start();
     }
}

重点：多线程的锁
1.都是同步方法，一个对象实例的时候
package TreadTest1;
import java.util.concurrent.TimeUnit;
class Phone{
     
      public synchronized void getIphone() throws InterruptedException{
          
          TimeUnit. SECONDS .sleep(3);
          System. out .println( "---------iphone" );
     }
     
      public synchronized void getAndroid(){
          System. out .println( "---------Android" );
          
          
     }
     
}
/**
 * 1.两个同步方法，一个对象的时候 ---------- 》
 *
 *
 *
 *
 * @author 77585211
 *
 */
  public class Test6 {
   public static void main(String[]  args ){
     Phone phone = new Phone();
     
      new Thread(()->{
          
           try {
               phone .getIphone();
          } catch (Exception e ) {
          
               e .printStackTrace();
          }
          
     }, "AA" ).start();
    new Thread(()->{
          
           phone .getAndroid();
          
     }, "BB" ).start();
  }
}

结果：
---------iphone
---------Android

原因：
如果一个类中有多个 synchronized(), 只要有一个线程进入了一个 synchronized方法，其他线程都要等待。 因为synchronized是锁整个this.Object，被锁定后，其他线程不能进入 synchronized方法

2. 两个同步方法，两个对象的时候


package TreadTest1;
import java.util.concurrent.TimeUnit;
class Phone{
     
      public synchronized void getIphone() throws InterruptedException{
          
          TimeUnit. SECONDS .sleep(3);
          System. out .println( "---------iphone" );
     }
     
      public synchronized void getAndroid(){
          System. out .println( "---------Android" );
          
          
     }
     
}
/**
 * 1.两个同步方法，一个对象的时候 ---------- 》 --------- iphone --------- Android
 * 2.两个同步方法，两个对象的时候 ---------- 》 --------- Android --------- iphone
 *
 *
 *
 * @author 77585211
 *
 */
  public class Test6 {
   public static void main(String[]  args ){
     Phone phone1 = new Phone();
     Phone phone2 = new Phone();
     
      new Thread(()->{
          
           try {
               phone1 .getIphone();
          } catch (Exception e ) {
          
               e .printStackTrace();
          }
          
     }, "AA" ).start();
    new Thread(()->{
          
           phone2 .getAndroid();
          
     }, "BB" ).start();
  }
}
结果： --------- Android --------- iphone
结论：synchronized只会锁this.object。 不会影响其他的对象实例
3. 两个同步方法，一个普通方法，一个对象
package TreadTest1;
import java.util.concurrent.TimeUnit;
class Phone{
     
      public synchronized void getIphone() throws InterruptedException{
          
          TimeUnit. SECONDS .sleep(3);
          System. out .println( "---------iphone" );
     }
     
      public synchronized void getAndroid(){
          System. out .println( "---------Android" );
     }
      public void sayHello(){
          
          System. out .println( "--------hello" );
          
     }
     
}
/**
 * 1.两个同步方法，一个对象的时候 ---------- 》 --------- iphone --------- Android
 * 2.两个同步方法，两个对象的时候 ---------- 》 --------- Android --------- iphone
 * 3.两个同步方法，一个普通方法，一个对象 -->---- hello ----- iphone ----- Android
 *
 *
 * @author 77585211
 *
 */
  public class Test6 {
   public static void main(String[]  args ){
     Phone phone1 = new Phone();
     Phone phone2 = new Phone();
     
      new Thread(()->{
          
           try {
               phone1 .getIphone();
          } catch (Exception e ) {
          
               e .printStackTrace();
          }
          
     }, "AA" ).start();
    new Thread(()->{
          
           phone1 .getAndroid();
          
     }, "BB" ).start();
  new Thread(()->{
          
           phone1 .sayHello();
          
     }, "CC" ).start();
  }
}

结论：
--------hello
---------iphone
---------Android

3.结论  没有同步锁的方法不会被锁住，只有加了synchronized的方法才能锁住当前线程。


4. 两个静态同步方法，一个对象
package TreadTest1;
import java.util.concurrent.TimeUnit;
class Phone{
     
      public static   synchronized void getIphone() throws InterruptedException{
          
          TimeUnit. SECONDS .sleep(3);
          System. out .println( "---------iphone" );
     }
     
      public static synchronized void getAndroid(){
          System. out .println( "---------Android" );
     }
      public void sayHello(){
          
          System. out .println( "--------hello" );
          
     }
     
}
/**
 * 1.两个同步方法，一个对象的时候 ---------- 》 --------- iphone --------- Android
 * 2.两个同步方法，两个对象的时候 ---------- 》 --------- Android --------- iphone
 * 3.两个同步方法，一个普通方法，一个对象 -->---- hello ----- iphone ----- Android
 * 4.两个静态同步方法，一个对象 ---- 》 --------- iphone --------- Android
 *
 * @author 77585211
 *
 */
  public class Test6 {
   public static void main(String[]  args ){
     Phone phone1 = new Phone();
     Phone phone2 = new Phone();
     
      new Thread(()->{
          
           try {
               phone1 . getIphone () ;
          } catch (Exception e ) {
          
               e .printStackTrace();
          }
          
     }, "AA" ).start();
    new Thread(()->{
          
           phone1 . getAndroid () ;
          
     }, "BB" ).start();
 
  }
}
结果：
---------iphone
---------Android
结论：所有静态同步方法用的锁是：类对象本身。

5. 两个静态同步方法，两个对象
package TreadTest1;
import java.util.concurrent.TimeUnit;
class Phone{
     
      public static   synchronized void getIphone() throws InterruptedException{
          
          TimeUnit. SECONDS .sleep(3);
          System. out .println( "---------iphone" );
     }
     
      public static   synchronized void getAndroid(){
          System. out .println( "---------Android" );
     }
      public void sayHello(){
          
          System. out .println( "--------hello" );
          
     }
     
}
/**
 * 1.两个同步方法，一个对象的时候 ---------- 》 --------- iphone --------- Android
 * 2.两个同步方法，两个对象的时候 ---------- 》 --------- Android --------- iphone
 * 3.两个同步方法，一个普通方法，一个对象 -->---- hello ----- iphone ----- Android
 * 4.两个静态同步方法，一个对象 ---- 》 --------- iphone --------- Android
 * 5.两个静态同步方法，两个对象 --- 》 --------- iphone --------- Android
 * @author 77585211
 *
 */
  public class Test6 {
   public static void main(String[]  args ){
     Phone phone1 = new Phone();
     Phone phone2 = new Phone();
     
      new Thread(()->{
          
           try {
               phone1 . getIphone () ;
          } catch (Exception e ) {
          
               e .printStackTrace();
          }
          
     }, "AA" ).start();
    new Thread(()->{
          
           phone2 . getAndroid () ;
          
     }, "BB" ).start();
 
  }
}

结果：
---------iphone
---------Android
结论： 静态同步方法不管是多少个对象实例，只要是一个类对象，当一个静态同步方法获取锁后，其他的静态同步方法必须等待。
6. 一个静态同步方法，一个非静态同步方法，一个对象
package TreadTest1;
import java.util.concurrent.TimeUnit;
class Phone{
     
      public static   synchronized void getIphone() throws InterruptedException{
          
          TimeUnit. SECONDS .sleep(3);
          System. out .println( "---------iphone" );
     }
     
      public synchronized void getAndroid(){
          System. out .println( "---------Android" );
     }
      public void sayHello(){
          
          System. out .println( "--------hello" );
          
     }
     
}
/**
 * 1.两个同步方法，一个对象的时候 ---------- 》 --------- iphone --------- Android
 * 2.两个同步方法，两个对象的时候 ---------- 》 --------- Android --------- iphone
 * 3.两个同步方法，一个普通方法，一个对象 -->---- hello ----- iphone ----- Android
 * 4.两个静态同步方法，一个对象 ---- 》 --------- iphone --------- Android
 * 5.两个静态同步方法，两个对象 --- 》 --------- iphone --------- Android
 * 6.一个静态同步方法，一个非静态同步方法，一个对象 --------- Android --------- iphone
 * @author 77585211
 *
 */
  public class Test6 {
   public static void main(String[]  args ){
     Phone phone1 = new Phone();
     Phone phone2 = new Phone();
     
      new Thread(()->{
          
           try {
               phone1 . getIphone () ;
          } catch (Exception e ) {
          
               e .printStackTrace();
          }
          
     }, "AA" ).start();
    new Thread(()->{
          
           phone1 .getAndroid();
          
     }, "BB" ).start();
 
  }
}

结果：
--------- Android -
-------- iphone
结论：静态同步方法锁住的是类对象，而非静态同步方法锁住的是当前对象实例。锁住的不是一个对象，所以syn的没有sleep的先被打印出来。
7： 一个静态同步方法，一个非静态同步方法，二个对象  
结果：
---------Android
---------iphone
结论：与6相同


创建多线程的方法4：线程池
题： 银行窗口办理业务      5个窗口    15个人办理业务  
package TreadTest1;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
/**
* 根据线程池创建多线程
* @author 77585211
*
*银行窗口办理业务      5个窗口    15个人办理业务
*利用线程池
*/
public class Test3 {
    public static void main(String[] args) throws InterruptedException, ExecutionException{
        //实现2秒钟一个，时间调度
         ScheduledExecutorService service = Executors.newScheduledThreadPool(5);//5个线程池
        ScheduledFuture<Integer>  schedule =null;
        //15个人办理业务
        try {
            for (int i = 1; i <=15; i++) {
        
                     schedule = service.schedule(()->{
                        
                        //打印一下当前线程的名字
                        System.out.print(Thread.currentThread().getName());
                        //返回一个随机数
                        return new Random().nextInt(30);
                        
                        
                    }, 2, TimeUnit.SECONDS);
            
                     System.out.println("-------rerult:"+schedule.get());
                
                
            }
            
            
        } finally{
            service.shutdown();
            
        }
    
        
        
    
        
    }
    
public static void getExecuor() throws Exception{
    //5个窗口
    //ExecutorService service = Executors.newFixedThreadPool(5);
    //ExecutorService service = Executors.newSingleThreadExecutor();一个线程
    ExecutorService service = Executors.newCachedThreadPool();//随机的线程池
    Future<Integer> result=null;
        //15个人办理业务
        try {
            for (int i = 1; i <=15; i++) {
                result = (Future<Integer>) service.submit(()->{
                    
                    //打印一下当前线程的名字
                    System.out.print(Thread.currentThread().getName());
                    //返回一个随机数
                    return new Random().nextInt(30);
                    
                    
                });
                //打印随机数
                System.out.println("----result:"+result.get());
            }
            
            
        } finally{
            service.shutdown();
            
        }
    
}
}



总结：当窗口固定，且要重复提交业务的时候，用线程池







Adobee Chen
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程总结
weixin_55782195的博客
08-12 169
文章目录一、多线程概述1.1 线程、进程、多线程二、线程实现（重点）2.1 继承Thread类2.2 实现Runnable接口2.3 实现Callable接口（了解即可）2.4 Lamda表达式三、线程状态3.1 停止线程3.2 线程休眠3.3 线程的优先级四、线程同步（重点）4.1 线程同步条件（队列和锁）4.2 同步方法和同步块4.2.1 同步方法4.2.2 同步块4.3 死锁4.4 lock锁 一、多线程概述 1.1 线程、进程、多线程 ◆程序是指令和数据的有序集合,其本身没有任何运行的含义，是一个
多线程（看这篇就够了！最全）
JavaSupeMan的博客
05-13 2万+
进程是电脑程序运行的最小单位，而线程则是进程的最小执行单位 多线程呢就是指一个进程运行时，多个线程并行交替执行的过程。可以提高代码的执行效离 解决多线程安全 1.使用synchronized synchronized的三种应用方式 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 2.使用lock锁 举例： public class a
多线程一，什么是多线程，创建多线程的几种方式
世上哪有什么岁月静好,不过是有人替你负重前行
04-11 2万+
1 多线程相关概念 并发（Concurrent）：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。 同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。 并行（Parallel）：当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，这种方式我们称之为
多线程详解
最新发布
2301_80026123的博客
07-12 716
线程与进程的关系 引入多线程方案就可以大大提高效率 进程和线程的概念与区别 线程创建的五种常用方式 介绍Thread类与属性 前台线程与后台线程 线程的终止（结束）
多线程详解（完结）
weixin_36490770的博客
12-05 4339
多线程学习笔记
多线程简介
Bug_marker的博客
11-29 4696
一、概念 1、并发与并行 并行：多个任务在同一个时刻点同时执行。效率高 并发：多个任务在同一段时间内分时执行。效率低，宏观上同时执行，微观上分时执行。 2、进程与线程 进程：内存中正在运行的应用程序，是系统进行资源分配和调度的基本单位。每一个进程有自己独立的运行空间，相互之间不影响。进程就是程序的一次执行过程，即是一个进程从加载到内存到从内存中释放消亡的过程。 线程：进程内部的独立运行单元，是操作系统能够进行运算调度的最小单位，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序.
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java虚拟机中多线程总结
08-25
Java虚拟机中多线程总结 Java虚拟机中多线程总结是指在Java虚拟机中，对多线程的知识点总结内容。本篇内容将从多线程的基本概念开始，讲解多线程的优点、缺点、分类、创建方式、同步机制等知识点，并且从JVM的角度...
多线程的简述
sunshixuan6666的博客
08-20 1763
Java多线程简述
多线程（超详细讲解）
qq_45903282的博客
10-28 944
多线程（超详细讲解）
多线程技术（全面介绍）
m0_60563771的博客
02-10 3818
最全的多线程介绍。从概念到掌握技术。
5个步骤，教你瞬间明白线程和线程安全
CSDN资讯
09-01 9万+
作者 |一个程序员的成长责编 | 胡巍巍记得今年3月份刚来杭州面试的时候，有一家公司的技术总监问了我这样一个问题：你来说说有哪些线程安全的类？我心里一想，这我早都背好了...
深入synchronized底层原理
程序员阿红的博客
05-04 1539
📝 个人主页：程序员阿红🔥 🎉 支持我：点赞👍收藏⭐️留言📝 📣 推荐文章：SSM整合🔥 🍗1. 引言 记得开始学习Java的时候，一遇到多线程情况就使用synchronized，相对于当时的我们来说synchronized是这么的神奇而又强大，那个时候我们赋予它一个名字“同步”，也成为了我们解决多线程情况的百试不爽的良药。 😈😈😈synchronized俗称：对象锁，专门用来锁对象的（这里不用过多关心对象的问题，反正你也不会有的😅）。 😺😺😺synchronized采用互斥的方式来保证同一时刻至多只有
多线程--入门看这一篇就够了！
weixin_46724181的博客
11-19 948
多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理“。1.为了了解多线程，我们还需要理解两个术语进程：进程是执行程序中的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
什么是多线程
qf2019的博客
08-18 9952
什么是多线程？ 多线程是一种同时执行多个线程的技术，它不允许进程或操作系统生成计算机中运行的程序的多个副本，而是在不创建程序多个副本的情况下，同时管理多个用户或同一用户的多个请求。 线程是轻量级进程，是处理的最小单元，同时运行多个线程称为多线程。因此，基本上，这是一种由多个处理器使用单个代码集的方法。 了解多线程 1.为了理解多线程，需要理解两个术语。 (1)线程：线程是进程的独立或基本单元。 (2)进程：正在执行的程序称为进程，一个进程中存在多个线程。 2.多线程中的执行是并发的和并行的。 (1)并发执行
Java多线程的知识点
weixin_59796310的博客
05-28 4888
Java多线程的知识点
Java多线程编程基础知识总结
Java多线程相关知识总结是Java编程语言中最重要的一部分，了解多线程的概念、进程和线程的关系、多线程并发、多核CPU和单核CPU、线程的生命周期、创建线程的两种方式等知识点，对于Java程序的开发和优化非常重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值