Java中的多线程Demo

一、关于Java多线程中的一些概念

1.1 线程基本概念

从JDK1.5开始，Java提供了3中方式来创建、启动多线程：

　　方式一（不推荐）、通过继承Thread类来创建线程类，重写run()方法作为线程执行体；

　　方式二、实现Runnable接口来创建线程类，重写run()方法作为线程执行体；

　　方式三、实现Callable接口来创建线程类，重写run()方法作为线程执行体；

不同的是，其中方式一的效果最差，是因为

　　1、线程类继承了Thread类，无法再继承其他父类；

　　2、因为每条线程都是一个Thread子类的实例，因此多个线程之间共享数据比较麻烦。

二、一些关于synchronized关键字的简单Demo

2.1、多个线程单个锁

当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排对是按照CPU分配的先后顺序而定的），一个线程想要执行synchronized修饰的方法里的代码首先会去尝试获得锁，如果拿到锁，执行synchronized代码体内容；

如果拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）

package com.sun.multithread.sync;

public class MyThread extends Thread {

    private int count = 5;
    
    // synchronized加锁
    public synchronized void run() {
        count--;
        System.out.println(this.currentThread().getName() + " count = " + count);
    }
    
    public static void main(String[] args) {
        
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread, "t1");
        Thread t2 = new Thread(myThread, "t2");
        Thread t3 = new Thread(myThread, "t3");
        Thread t4 = new Thread(myThread, "t4");
        Thread t5 = new Thread(myThread, "t5");
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

2.2、多个线程多把锁

关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当成锁，所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁。但是在静态(static)方法上加synchronized关键字，表示锁定class类，类级别的锁

package com.sun.multithread.sync;

public class MultiThread {
    
    private static int num = 0;
    
    /**
     * 在静态(static)方法上加synchronized关键字，表示锁定class类，类级别的锁
     *
     * 关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当成锁，
     * 所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁
     * 
     * @param tag 参数
     */
    public static 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!");
            }
            System.out.println("tag " + tag + ", num = " + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        // 两个不同的对象
        final MultiThread m1 = new MultiThread();
        final MultiThread m2 = new MultiThread();
        
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                m1.printNum("a");
            }
        });
        
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                m1.printNum("b");
            }
        });
        
        t1.start();
        t2.start();
    }
}

 2.3 银行取钱的多线程例子

1、创建一个银行账户，并在里面写好取钱的方法，其中使用synchronized关键字修饰多线程操作的方法

package com.sun.multithread.sync.bankdemo;

/**
 * 银行账户类
 * 
 * @author ietree
 */
public class Account {

    /**
     * 账号
     */
    private String accountNo;

    /**
     * 余额
     */
    private double balance;

    public Account() {
    }

    /**
     * 带参构造函数
     * 
     * @param accountNo 账户
     * @param balance 余额
     */
    public Account(String accountNo, double balance) {
        this.accountNo = accountNo;
        this.balance = balance;
    }
    
    // 访问该账户的余额，使用synchronized修饰符将它变成同步方法
    public synchronized double getBalance() {
        return balance;
    }
        
    /**
     * 取钱的方法
     * 
     * @param drawAmount 取钱金额
     */
    public synchronized void draw(double drawAmount) {

        // 如果余额大于等于用户取的钱，则取款成功
        if (balance >= drawAmount) {
            // 取款成功
            System.out.println(Thread.currentThread().getName() + "取钱成功！用户取出" + drawAmount + "元");

            // 修改余额
            balance -= drawAmount;
            System.out.println("\t余额为： " + balance);
            
        } else {
            
            System.out.println(Thread.currentThread().getName() + "取钱失败！您的余额不足");
            
        }

    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    // 重写hashCode()方法
    public int hashCode() {
        return accountNo.hashCode();
    }

    // 重写equals()方法
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == Account.class) {
            Account target = (Account) obj;
            return target.accountNo.equals(accountNo);
        }
        return false;
    }

}

2、创建多个线程同时操作一个账户

package com.sun.multithread.sync.bankdemo;

class DrawThread extends Thread {
    
    /**
     * 模拟用户账户
     */
    private Account account;
    
    /**
     * 当前取钱线程所希望取的钱数
     */
    private double drawAmount;
    
    public DrawThread(String name, Account account, double drawAmount){
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }
    
    // 当多条线程修改同一个共享数据时，将涉及数据安全问题
    public void run(){
        account.draw(drawAmount);
    }
}

public class DrawTest {
    
    public static void main(String[] args) {
        // 创建一个账户
        Account acct = new Account("1234567", 1000);
        
        // 模拟两个线程对同一账户取钱
        new DrawThread("路人甲", acct, 800).start();
        new DrawThread("路人乙", acct, 800).start();
    }
    
    
}

 2.4 业务整体需要使用完整的synchronized，保持业务的原子性

package com.ietree.multithread.sync;

/**
 * 业务整体需要使用完整的synchronized，保持业务的原子性
 * 
 * @author ietree
 */
public class DirtyRead {

    private String username = "Jack";
    private String password = "123";

    public synchronized void setValue(String username, String password) {
        this.username = username;

        try {
            // 睡眠2秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        this.password = password;

        System.out.println("setValue最终结果：username = " + username + ", password = " + password);
    }

    // synchronized
    public void getValue() {
        System.out.println("getValue方法得到：username = " + this.username + ", password = " + this.password);
    }

    public static void main(String[] args) throws Exception {

        final DirtyRead dr = new DirtyRead();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                dr.setValue("Dylan", "456");
            }
        });
        t1.start();
        Thread.sleep(1000);

        dr.getValue();
    }

}

程序输出：

getValue方法得到：username = Dylan, password = 123
setValue最终结果：username = Dylan, password = 456

这里出现了脏读现象，应该要保持业务的原子性，修改如下：

package com.ietree.multithread.sync;

/**
 * 业务整体需要使用完整的synchronized，保持业务的原子性
 * 
 * @author ietree
 */
public class DirtyRead {

    private String username = "Jack";
    private String password = "123";

    public synchronized void setValue(String username, String password) {
        this.username = username;

        try {
            // 睡眠2秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        this.password = password;

        System.out.println("setValue最终结果：username = " + username + ", password = " + password);
    }

    // synchronized
    public synchronized void getValue() {
        System.out.println("getValue方法得到：username = " + this.username + ", password = " + this.password);
    }

    public static void main(String[] args) throws Exception {

        final DirtyRead dr = new DirtyRead();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                dr.setValue("Dylan", "456");
            }
        });
        t1.start();
        Thread.sleep(1000);

        dr.getValue();
    }

}

程序输出：

setValue最终结果：username = Dylan, password = 456
getValue方法得到：username = Dylan, password = 456

当在set和get方法上同时使用了synchronized能确保业务原子性，不会出现脏读现象。

 2.5 synchronized的重入

demo1：

package com.ietree.multithread.sync;

public class SyncDemo1 {

    public synchronized void method1(){
        System.out.println("method1..");
        method2();
    }
    public synchronized void method2(){
        System.out.println("method2..");
        method3();
    }
    public synchronized void method3(){
        System.out.println("method3..");
    }
    
    public static void main(String[] args) {
        final SyncDemo1 sd = new SyncDemo1();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                sd.method1();
            }
        });
        t1.start();
    }

}

demo2：

package com.ietree.multithread.sync;

public class SyncDemo2 {
    
    static class Parent {
        public int i = 10;

        public synchronized void operationSup() {
            try {
                i--;
                System.out.println("Main print i = " + i);
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class Sub extends Parent {
        public synchronized void operationSub() {
            try {
                while (i > 0) {
                    i--;
                    System.out.println("Sub print i = " + i);
                    Thread.sleep(100);
                    this.operationSup();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                Sub sub = new Sub();
                sub.operationSub();
            }
        });

        t1.start();
    }
}

2.6 synchronized的Exception

package com.ietree.multithread.sync;

public class SyncException {

    private int i = 0;

    public synchronized void operation() {
        while (true) {
            try {
                i++;
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + " , i = " + i);
                if (i == 20) {
                    throw new RuntimeException();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        final SyncException se = new SyncException();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                se.operation();
            }
        }, "t1");
        t1.start();
    }
}

 2.7 锁对象的改变问题

demo1:

package com.ietree.multithread.sync;

public class ChangeLock {
    
    private String lock = "lock";

    private void method() {
        synchronized (lock) {
            try {
                System.out.println("当前线程 : " + Thread.currentThread().getName() + "开始");
                lock = "change lock";
                Thread.sleep(2000);
                System.out.println("当前线程 : " + Thread.currentThread().getName() + "结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        final ChangeLock changeLock = new ChangeLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                changeLock.method();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                changeLock.method();
            }
        }, "t2");
        t1.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

程序输出：

当前线程 : t1开始
当前线程 : t2开始
当前线程 : t1结束
当前线程 : t2结束

demo2:

package com.ietree.multithread.sync;

public class ChangeLock {

    private String lock = "lock";

    private void method() {
        synchronized (lock) {
            try {
                System.out.println("当前线程 : " + Thread.currentThread().getName() + "开始");
                // lock = "change lock";
                Thread.sleep(2000);
                System.out.println("当前线程 : " + Thread.currentThread().getName() + "结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        final ChangeLock changeLock = new ChangeLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                changeLock.method();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                changeLock.method();
            }
        }, "t2");
        t1.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

程序输出：

当前线程 : t1开始
当前线程 : t1结束
当前线程 : t2开始
当前线程 : t2结束

两个程序相比差异在于是否含有 lock = "change lock";这个改变了锁对象，所以输出有差异。

2.8 死锁问题，在设计程序时就应该避免双方相互持有对方的锁的情况

package com.ietree.multithread.sync;

public class DeadLock implements Runnable {
    
    private String tag;
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public void setTag(String tag) {
        this.tag = tag;
    }

    @Override
    public void run() {
        if (tag.equals("a")) {
            synchronized (lock1) {
                try {
                    System.out.println("当前线程 : " + Thread.currentThread().getName() + " 进入lock1执行");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("当前线程 : " + Thread.currentThread().getName() + " 进入lock2执行");
                }
            }
        }
        if (tag.equals("b")) {
            synchronized (lock2) {
                try {
                    System.out.println("当前线程 : " + Thread.currentThread().getName() + " 进入lock2执行");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("当前线程 : " + Thread.currentThread().getName() + " 进入lock1执行");
                }
            }
        }
    }

    public static void main(String[] args) {

        DeadLock d1 = new DeadLock();
        d1.setTag("a");
        DeadLock d2 = new DeadLock();
        d2.setTag("b");

        Thread t1 = new Thread(d1, "t1");
        Thread t2 = new Thread(d2, "t2");

        t1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

程序输出：

当前线程 : t1 进入lock1执行
当前线程 : t2 进入lock2执行

程序一直等待获取锁的状态，造成死锁问题。

2.9 同一对象属性的修改不会影响锁的情况

package com.ietree.multithread.sync;

public class ModifyLock {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public synchronized void changeAttributte(String name, int age) {
        try {
            System.out.println("当前线程 : " + Thread.currentThread().getName() + " 开始");
            this.setName(name);
            this.setAge(age);

            System.out.println("当前线程 : " + Thread.currentThread().getName() + " 修改对象内容为： " + this.getName() + ", "
                    + this.getAge());

            Thread.sleep(2000);
            System.out.println("当前线程 : " + Thread.currentThread().getName() + " 结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        
        final ModifyLock modifyLock = new ModifyLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                modifyLock.changeAttributte("Jack", 18);
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                modifyLock.changeAttributte("Rose", 20);
            }
        }, "t2");

        t1.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

程序输出：

当前线程 : t1 开始
当前线程 : t1 修改对象内容为： Jack, 18
当前线程 : t1 结束
当前线程 : t2 开始
当前线程 : t2 修改对象内容为： Rose, 20
当前线程 : t2 结束

2.10 使用synchronized代码块加锁,比较灵活

package com.ietree.multithread.sync;

public class ObjectLock {
    public void method1() {
        synchronized (this) { // 对象锁
            try {
                System.out.println("do method1..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void method2() { // 类锁
        synchronized (ObjectLock.class) {
            try {
                System.out.println("do method2..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private Object lock = new Object();

    public void method3() { // 任何对象锁
        synchronized (lock) {
            try {
                System.out.println("do method3..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        final ObjectLock objLock = new ObjectLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method1();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method2();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method3();
            }
        });

        t1.start();
        t2.start();
        t3.start();

    }
}

程序输出：

do method2..
do method3..
do method1..

以上语句是同时输出的，因为他们拿到的锁都是不同的锁，所以互不影响。

2.11 使用synchronized代码块减小锁的粒度，提高性能

package com.ietree.multithread.sync;

public class Optimize {
    
    public void doLongTimeTask() {
        try {
            System.out.println("当前线程开始：" + Thread.currentThread().getName() + ", 正在执行一个较长时间的业务操作，其内容不需要同步");
            Thread.sleep(2000);

            synchronized (this) {
                System.out.println("当前线程：" + Thread.currentThread().getName() + ", 执行同步代码块，对其同步变量进行操作");
                Thread.sleep(1000);
            }
            System.out.println("当前线程结束：" + Thread.currentThread().getName() + ", 执行完毕");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        final Optimize otz = new Optimize();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                otz.doLongTimeTask();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                otz.doLongTimeTask();
            }
        }, "t2");
        t1.start();
        t2.start();

    }
}

程序输出：

当前线程开始：t2, 正在执行一个较长时间的业务操作，其内容不需要同步
当前线程开始：t1, 正在执行一个较长时间的业务操作，其内容不需要同步
当前线程：t1, 执行同步代码块，对其同步变量进行操作
当前线程结束：t1, 执行完毕
当前线程：t2, 执行同步代码块，对其同步变量进行操作
当前线程结束：t2, 执行完毕

2.12 避免使用字符串常量锁

package com.ietree.multithread.sync;

public class StringLock {
    
    public void method() {
        // new String("字符串常量")
        synchronized ("字符串常量") {
            try {
                while (true) {
                    System.out.println("当前线程 : " + Thread.currentThread().getName() + "开始");
                    Thread.sleep(1000);
                    System.out.println("当前线程 : " + Thread.currentThread().getName() + "结束");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        final StringLock stringLock = new StringLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                stringLock.method();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                stringLock.method();
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

程序输出：

当前线程 : t1开始
当前线程 : t1结束
当前线程 : t1开始
当前线程 : t1结束
当前线程 : t1开始
当前线程 : t1结束
当前线程 : t1开始
......