java——多线程的实现方式、三种办法解决线程赛跑、多线程数据同步(synchronized)、死锁

多线程的实现方式:demo1、demo2

demo1:继承Thread类,重写run()方法

package thread_test;

public class ThreadDemo1 extends Thread {
    ThreadDemo1(){
        
    }
    ThreadDemo1(String szName){
        super(szName);
    }
    
    //重载run函数
    public void run() {
        for(int count = 1 , row = 1 ; row < 10 ; row ++ , count ++) {
            for(int i = 0 ; i < count ; i ++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
    
    public static void main(String[] args) {
        //线程赛跑
        ThreadDemo1 td1 = new ThreadDemo1();
        ThreadDemo1 td2 = new ThreadDemo1();
        ThreadDemo1 td3 = new ThreadDemo1();
        td1.start();
        td2.start();
        td3.start();
    }

}

demo2:实现runnable接口,实现run()方法

package thread_test;

public class ThreadDemo2 implements Runnable{

    public void run() {
        for(int count = 1 , row = 1 ; row < 10 ; row ++ , count ++) {
            for(int i = 0 ; i < count ; i ++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
    
    public static void main(String[] args) {
        //存在线程赛跑问题
        Runnable rb1 = new ThreadDemo2();
        Runnable rb2 = new ThreadDemo2();
        Runnable rb3 = new ThreadDemo2();
        Thread td1 = new Thread(rb1);
        Thread td2 = new Thread(rb2);
        Thread td3 = new Thread(rb3);
        td1.start();
        td2.start();
        td3.start();
    }
}

demo3:两种方法解决进程赛跑问题

package thread_test;

//两种方法解决线程赛跑
class ThreadWait extends Thread{

    public ThreadWait() {
        
    }
    
    public ThreadWait(String name) {
        super(name);
    }
    
    @Override
    public void run() {
        for(int count = 1 , row = 1 ; row < 10 ; row ++ , count ++) {
            for(int i = 0 ; i < count ; i ++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

public class ThreadDemo3{
    public static void main(String[] args) {
        ThreadDemo3 td = new ThreadDemo3();
//        td.Method1();
        td.Method2();
    }
    
    public void Method1() {
        ThreadWait tw1 = new ThreadWait();
        ThreadWait tw2 = new ThreadWait();
        tw1.start();
        while(tw1.isAlive()) {
            try{
                Thread.sleep(100);
            }catch(Exception e){
                e.getMessage();
            }
        }
        tw2.start();
    }
    
    public void Method2() {
        ThreadWait tw1 = new ThreadWait();
        ThreadWait tw2 = new ThreadWait();
        tw1.start();
        try {
            tw1.join(); // 等待该线程中止
        }catch(Exception e){
            e.toString();
        }
        tw2.start();
    }
}

线程异步访问数据导致问题:

package thread_test;

//线程异步访问数据导致问题
class ShareData{
    public static String szData = "";
}

class ThreadDemo extends Thread{
    
    private static ShareData oShare;
    
    ThreadDemo(){
    }
    
    ThreadDemo(String name, ShareData oShare){
        super(name);
        this.oShare = oShare;
    }
    
    public void run() {
        for(int i = 0 ; i < 5 ; i ++) {
            if(this.getName().equals("th1")) {
                oShare.szData = "这是第一个进程";
                try {
                    Thread.sleep(100);
                }catch(Exception e) {
                    
                }
                System.out.println(this.getName() + oShare.szData);
            }else if(this.getName().equals("th2")) {
                oShare.szData = "这是第二个进程";
                try {
                    Thread.sleep(100);
                }catch(Exception e) {
                    
                }
                System.out.println(this.getName() + oShare.szData);
            }
        }
    }
}

 public class ThreadDemo5 {

    public static void main(String[] args) {
        ShareData oShare = new ShareData();
        ThreadDemo th1 = new ThreadDemo("th1", oShare);
        ThreadDemo th2 = new ThreadDemo("th2", oShare);
        th1.start();
        th2.start();
    }
}

得到的结果并不是我们想要的:

《java——多线程的实现方式、三种办法解决线程赛跑、多线程数据同步(synchronized)、死锁》

解决办法:

  通过“锁”解决线程赛跑问题并实现多线程数据同步:

package thread_test;
class ShareData0{ public static String szData = ""; } class ThreadDemo0 extends Thread{ private static ShareData0 oShare; ThreadDemo0(){ } ThreadDemo0(String name, ShareData0 oShare){ super(name); this.oShare = oShare; } public void run() { //同步快,并指出同步数据oShare synchronized(oShare){ for(int i = 0 ; i < 5 ; i ++) { if(this.getName().equals("th1")) { oShare.szData = "这是第一个进程"; try { Thread.sleep(100); }catch(Exception e) { } System.out.println(this.getName() + oShare.szData); }else if(this.getName().equals("th2")) { oShare.szData = "这是第二个进程"; try { Thread.sleep(100); }catch(Exception e) { } System.out.println(this.getName() + oShare.szData); } } } } } public class ThreadDemo6 { public static void main(String[] args) { ShareData0 oShare = new ShareData0(); ThreadDemo0 th1 = new ThreadDemo0("th1", oShare); ThreadDemo0 th2 = new ThreadDemo0("th2", oShare); th1.start(); th2.start(); } }

得到结果:

《java——多线程的实现方式、三种办法解决线程赛跑、多线程数据同步(synchronized)、死锁》

死锁:由于两个线程都在等待对方释放各自拥有的锁的现象称为死锁,这种现象往往是由于相互潜逃的synchronized代码段而造成的,所以少用synchronized嵌套。

下面是一个死锁的例子:

package thread_test;

public class LockedThread extends Thread{
    
    private static Object A = new Object();
    private static Object B = new Object();
    private static boolean flag = true;
    
    public static void main(String[] args) {
        LockedThread th1 = new LockedThread();
        LockedThread th2 = new LockedThread();
        
        th1.start();
        th2.start();
    }
    
    public void AccessA() {
        flag = false;
        synchronized(A) {
            System.out.println("th1获得了A的锁");
            try {
                Thread.sleep(1000);
            }catch(Exception e) {
                
            }
            System.out.println("th1还想要B的锁");
            synchronized(B) {
                System.out.println("th1获得了B的锁");
            }
        }
    }
    
    public void AccessB() {
        flag = true;
        synchronized(B) {
            System.out.println("th2获得了B的锁");
            try {
                Thread.sleep(1000);
            }catch(Exception e) {
                
            }
            System.out.println("th2还想要A的锁");
            synchronized(A) {
                System.out.println("th2获得了A的锁");
            }
        }
    }
    
    public void run(){
        if(flag) {
            AccessA();
        }else {
            AccessB();
        }
    }

}

显示结果:

《java——多线程的实现方式、三种办法解决线程赛跑、多线程数据同步(synchronized)、死锁》

程序没有结束 而是停在了这里,这就是死锁。

 

    原文作者:高圈圈
    原文地址: https://www.cnblogs.com/gaoquanquan/p/9912000.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞