互联网并发编程（2）--线程基础

谁借莪１个温暖的怀抱￠ 2022-05-28 01:07 204阅读 0赞

内容：  
多个线程多个锁，对象锁和类锁  
对象锁的同步和异步

--------------------

## 对象锁和类锁 ##

概念  
1 多个线程多个锁  
多个线程，每个线程都可以拿到自己指定的锁，分别获得锁之后，执行synchronized方法体的内容。

package com.wuk.thread;
    
    public class ThreadTest02 extends Thread{ 
    
        private  int num = 0;
    
        public  synchronized void printNum(String tag){
    
            try {
                if(tag.equals("a")){
    
                    num=100;
                    System.out.println("tag a , set num over!");
                    Thread.sleep(1000);
                }else {
    
                    num=200;
                    System.out.println("tag b,set num over!");
                }
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
    
            System.out.println("tag"+tag+",num="+num);
        }
    
        public static void main(String[] args) {
    
            //定义创建两个不同对象
            final ThreadTest02 tt1=new ThreadTest02();
            final ThreadTest02 tt2=new ThreadTest02();
    
            Thread t1=new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    tt1.printNum("a");
    
                }
            });
    
            Thread t2=new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    tt2.printNum("b");
    
                }
            });
    
            t1.start();
            t2.start();
        }
    }

输出结果：  
各自线程输出各自的互不影响，因为他们是不同的对象，各自持有各自对象的锁，所以各自执行互不干涉。

tag a , set num over!
    tag b,set num over!
    tagb,num=200
    taga,num=100

但是如果给printNum（）加上static，这样无论你创建多少个对象，锁只有一把，是属于类级别的锁，而非对象。也就是说如果将synchronized 加在静态方法上就表示该锁是类级别锁，而非对象锁。  
输出结果：  
一个个执行，线程1执行完了以后释放锁，线程2才可以执行。

tag a , set num over!
    taga,num=100
    tag b,set num over!
    tagb,num=200

## 对象锁的同步和异步 ##

同步 synchronized  
同步的概念就是共享，如果不是共享就没有必要同步。  
异步 asynchronized  
异步的概念就是独立，相互之间不受任何制约。

同步的目的就是就是为了线程安全，对于线程安全需要满足两个特性：原子性（同步），可见性。

package com.wuk.thread;
    
    public class ThreadTest03 extends Thread{ 
    
         public synchronized void method1(){
    
             System.out.println(Thread.currentThread().getName());
             try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
         }
    
         public  void method2(){
    
             System.out.println(Thread.currentThread().getName());
         }
    
         public static void main(String[] args) {
    
             final ThreadTest03 tt=new ThreadTest03();
    
             Thread thread01=new Thread(new Runnable() {
    
                @Override
                public void run() {
                    tt.method1();
                }
            },"thread01");
    
             Thread thread02=new Thread(new Runnable() {
    
                    @Override
                    public void run() {
                        tt.method2();
                    }
                },"thread02");
    
             thread01.start();
             thread02.start();
        }
    }

结果：  
同时打印出来，因为这是异步的，相互之间不影响。

thread01
    thread02

给method1()，method2()同时加上synchronized，这样两个方法同步，也就是说只有当线程1执行method1()完毕释放锁，线程2才能执行。