线程的创建

 

创建线程

创建线程的三种方法：

• 实现接口Runnable。
• 继承Thread类。
• 通过 Callable 和 Future 创建线程。

1. 实现Callable接口创建线程，可以得到执行结果，可以抛异常。并且可以取消任务。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableTest implements Callable<Integer> {

	@Override
	public Integer call() throws Exception {
		System.out.println("我是线程"+Thread.currentThread().getId());
		return 1;
	}
	
	public static void main(String[] args) {
		CallableTest task = new CallableTest();
		ExecutorService threadPool = Executors.newFixedThreadPool(10);
		for(int i=0; i<10;i++) {
			Future<Integer> future = threadPool.submit(task);
			
			try {
				Integer result = future.get();
				System.out.println(result);
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		
		}
		threadPool.shutdown();
		System.out.println("所有任务执行完毕");
	}
	
}

结果

我是线程10
1
我是线程11
1
我是线程12
1
我是线程13
1
我是线程14
1
我是线程15
1
我是线程16
1
我是线程17
1
我是线程18
1
我是线程19
1
所有任务执行完毕

 

2.实现接口Runnable创建线程，并重写run方法。run方法为多线程的代码块。通过start方法来启动线程进去就绪状态，如果就绪状态的线程获取 CPU 资源，就可以执行 run()，进入运行状态。

class RunnableTest implements Runnable {
	private String threadName;
	
	public RunnableTest(String name) {
		threadName = name;
	}
	
	@Override
	public void run() {
		for(int i=10;i>0;i--) {
			System.out.println("Thread:"+threadName+"running"+   i);
			try {
				Thread.sleep(new Random().nextInt(50)+40);
			} catch (InterruptedException e) {
				System.out.println("出现异常！！");
				e.printStackTrace();
			}
		}
	}
	
	public void start () {
		System.out.println("Thread:"+threadName+"start");
	}
	
}
public class ThreadTestImple{
	public static void main(String[] args) {
		RunnableTest threadA = new RunnableTest("thread A ");
		Thread thread1 = new Thread(threadA);
		thread1.start();
		
		RunnableTest threadB = new RunnableTest("thread B ");
		Thread thread2 = new Thread(threadB);
		thread2.start();
	}
}

输出结果如下

Thread:thread A running10
Thread:thread B running10
Thread:thread A running9
Thread:thread B running9
Thread:thread B running8
Thread:thread A running8
Thread:thread A running7
Thread:thread B running7
Thread:thread A running6
Thread:thread B running6
Thread:thread A running5
Thread:thread A running4
Thread:thread B running5
Thread:thread A running3
Thread:thread B running4
Thread:thread A running2
Thread:thread B running3
Thread:thread A running1
Thread:thread B running2
Thread:thread B running1 

 3.继承Thread类实现多线程

class ThreadDemo extends Thread {
	private String threadName;
	
	public ThreadDemo(String name) {
		threadName = name;
	}
	//重写run函数
	public void run() {
		for(int i=10;i>0;i--) {
			
			try {
				System.out.println("Thread:"+threadName+"running"+   i);
				Thread.sleep(new Random().nextInt(500)+100);
			} catch (InterruptedException e) {
				System.out.println("出现异常！！");
				e.printStackTrace();
			}
		}
	}
	
}
public class ThreadTest {
	
	public static void main(String[] args) {
		ThreadDemo threadDemo1 = new ThreadDemo("threadDemo 1 ");
		threadDemo1.start();
		
		ThreadDemo threadDemo2 = new ThreadDemo("threadDemo 2 ");
		threadDemo2.start();
	}
}

运行结果
 

Thread:threadDemo 1 running10
Thread:threadDemo 2 running10
Thread:threadDemo 1 running9
Thread:threadDemo 2 running9
Thread:threadDemo 1 running8
Thread:threadDemo 2 running8
Thread:threadDemo 1 running7
Thread:threadDemo 2 running7
Thread:threadDemo 1 running6
Thread:threadDemo 2 running6
Thread:threadDemo 1 running5
Thread:threadDemo 2 running5
Thread:threadDemo 1 running4
Thread:threadDemo 1 running3
Thread:threadDemo 2 running4
Thread:threadDemo 1 running2
Thread:threadDemo 2 running3
Thread:threadDemo 1 running1
Thread:threadDemo 2 running2
Thread:threadDemo 2 running1
 

使用线程应注意的问题

在线程的使用中在对共享资源的访问时应该注意到线程安全，避免脏读。

如例1：

public class ThreadTest {

    public static void main(String[] args) {
        Account account = new Account("123456", 1000);
        DrawMoneyRunnable drawMoneyRunnable = new DrawMoneyRunnable(account, 700);
        Thread myThread1 = new Thread(drawMoneyRunnable);
        Thread myThread2 = new Thread(drawMoneyRunnable);
        myThread1.start();
        myThread2.start();
    }

}

class DrawMoneyRunnable implements Runnable {

    private Account account;
    private double drawAmount;

    public DrawMoneyRunnable(Account account, double drawAmount) {
        super();
        this.account = account;
        this.drawAmount = drawAmount;
    }

    public void run() {
        if (account.getBalance() >= drawAmount) {  //1
            System.out.println("取钱成功， 取出钱数为：" + drawAmount);
            double balance = account.getBalance() - drawAmount;
            account.setBalance(balance);
            System.out.println("余额为：" + balance);
        }
    }
}

class Account {

    private String accountNo;
    private double balance;

    public Account() {

    }

    public Account(String accountNo, double balance) {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public String getAccountNo() {
        return accountNo;
    }

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

}

运行结果

取钱成功， 取出钱数为：700.0
余额为：300.0
取钱成功， 取出钱数为：700.0
余额为：-400.0

显然结果是不正确的。 

三种解决方案：

• synchronized同步方法
• synchronized同步代码块
• Lock对象同步锁(Lock)

synchronized同步方法 :

语法为

public synchronized void run(){

}

将例1，run方法改为

//使用synchronized修饰run方法
public synchronized void run() {
    	
		if (account.getBalance() >= drawAmount) {  //1
            System.out.println("取钱成功， 取出钱数为：" + drawAmount);
            double balance = account.getBalance() - drawAmount;
            account.setBalance(balance);
            System.out.println("余额为：" + balance);
        }

运行结果

取钱成功， 取出钱数为：700.0
余额为：300.0

synchronized同步代码块,参数为公共资源。

synchronized(Object obj){

}

 将例1，run方法改为

public void run() {
    	synchronized (account) {
    		if (account.getBalance() >= drawAmount) {  //1
                System.out.println("取钱成功， 取出钱数为：" + drawAmount);
                double balance = account.getBalance() - drawAmount;
                account.setBalance(balance);
                System.out.println("余额为：" + balance);
            }
}

运行结果

取钱成功， 取出钱数为：700.0
余额为：300.0

Lock对象同步锁(Lock)

语法

Lock.lock()
try{

}finally{
   Lock.unlock() 
}

 将例1，run方法改为

public void run() {
    	lock.lock();
		try {
			if (account.getBalance() >= drawAmount) {  //1
                System.out.println("取钱成功， 取出钱数为：" + drawAmount);
                double balance = account.getBalance() - drawAmount;
                account.setBalance(balance);
                System.out.println("余额为：" + balance);
            }
		} finally {
			lock.unlock();
		}
}

结果为

 

取钱成功， 取出钱数为：700.0
余额为：300.0

       因此，讲到线程安全问题，其实是指多线程环境下对共享资源的访问可能会引起此共享资源的不一致性。因此，为避免线程安全问题，应该避免多线程环境下对此共享资源的并发访问。