java基础：多线程

public class FirstThread extends Thread {

	private int i;

	// 重写run方法，run()方法的方法体就是线程执行体
	@Override
	public void run() {
		for (; i < 20; i++) {
			// 当线程类继承Thread类时，直接使用this即可获取当前线程
			// Thread对象的getName()方法返回当前线程的名字
			System.out.println("run：" + getName() + " " + i);
		}
	}

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

		// 为主线程设置名称，默认名称为main
		Thread.currentThread().setName("main：");

		for (int i = 0; i < 20; i++) {
			// 调用Thread类的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName() + " " + i);

			if (i == 10) {
				// 创建并启动第一个线程
				FirstThread firstThread = new FirstThread();
				firstThread.setName("first：");
				firstThread.start();

				// 创建并启动第二个线程
				FirstThread secondThread = new FirstThread();
				secondThread.setName("second：");
				secondThread.start();
			}
		}
	}

}

public class SecondThread implements Runnable {

	private int i;

	// 重写run方法，run()方法同样是线程执行体
	@Override
	public void run() {
		for (; i < 20; i++) {
			// 当线程类实现Runable接口时，如果想获取当前线程，只能用Thread.currentThread()方法
			// Thread对象的getName()方法返回当前线程的名称
			System.out.println("run：" + Thread.currentThread().getName() + " " + i);
		}
	}

	public static void main(String[] args) {

		// 为主线程设置名称，默认名称为main
		Thread.currentThread().setName("main：");

		for (int i = 0; i < 20; i++) {
			// 调用Thread类的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName() + " " + i);

			if (i == 10) {
				SecondThread st = new SecondThread();

				// 通过new Thread(target, name)方法创建新线程
				// 创建并启动第一个线程
				Thread firstThread = new Thread(st, "first：");
				firstThread.start();

				// 创建并启动第二个线程
				Thread secondThread = new Thread(st, "second：");
				secondThread.start();
			}
		}
	}

}

public class ThirdThread implements Callable<Integer> {

	private int i;

	// 重写call()方法，call()方法的方法体就是线程执行体
	@Override
	public Integer call() throws Exception {
		for (; i < 20; i++) {
			// Thread对象的getName()方法返回当前线程的名称
			System.out.println("run：" + Thread.currentThread().getName() + " " + i);
		}
		return i;
	}

	public static void main(String[] args) {

		// 为主线程设置名称，默认名称为main
		Thread.currentThread().setName("main：");

		for (int i = 0; i < 20; i++) {
			// 调用Thread类的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName() + " " + i);

			if (i == 10) {
				Callable<Integer> callable = new ThirdThread();

				// 使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象中call()方法的返回值
				FutureTask<Integer> ft = new FutureTask<Integer>(callable);

				// 创建并启动线程
				Thread thread = new Thread(ft, "thread：");
				thread.start();

				// 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
				try {
					System.out.println("return：" + ft.get());
				}
				catch (InterruptedException | ExecutionException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

public class StartDead extends Thread {

	private int i;

	@Override
	public void run() {
		for (; i < 20; i++) {
			// 当线程类继承Thread类时，直接使用this即可获取当前线程
			// Thread对象的getName()方法返回当前线程的名称
			System.out.println("run：" + getName() + " " + i);
		}
	}

	public static void main(String[] args) {
		// 为主线程设置名称，默认名称为main
		Thread.currentThread().setName("main：");

		for (int i = 0; i < 20; i++) {
			// 调用Thread类的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName() + " " + i);

			if (i == 10) {
				// 创建并启动第一个线程
				StartDead sd = new StartDead();
				sd.setName("first：");
				// 判断启动后线程的isAlive()值
				System.out.println(sd.isAlive());

				sd.start();

				// 判断启动后线程的isAlive()值
				System.out.println(sd.isAlive());
				// 再次调用start()，java.lang.IllegalThreadStateException异常
				sd.start();
			}
		}
	}

}

public class JoinThread extends Thread {

	// 提供一个有参数的构造器，用于设置该线程的名字
	public JoinThread(String name) {
		super(name);
	}

	// 重写run()方法，定义线程执行体
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println("run：" + getName() + " " + i);
		}
	}

	public static void main(String[] args) throws InterruptedException {
		// 创建并启动第一个子线程
		JoinThread firstThread = new JoinThread("first：");
		firstThread.start();

		for (int i = 0; i < 20; i++) {
			if (i == 10) {
				// 创建并启动第二个子线程
				JoinThread jt = new JoinThread("join：");
				jt.start();

				// main线程调用了jt线程的join()方法，main线程必须等jt执行结束才会向下执行
				jt.join();
			}
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}

}

public class DaemonThread extends Thread {

	// 定义后台线程的线程执行体与普通线程没有任何区别
	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			System.out.println("run：" + getName() + " " + i);
		}
	}

	public static void main(String[] args) {
		DaemonThread dt = new DaemonThread();
		dt.setName("first：");
		// 将此线程设置成后台线程
		dt.setDaemon(true);
		// 启动后台线程
		dt.start();

		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
		// 程序执行到此结束，前台线程（main）结束，后台线程也应该随之结束
	}

}

public class SleepTest {

	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 5; i++) {
			System.out.println("当前时间:" + new Date());

			// 调用sleep()方法让当前线程(主线程)暂停2s
			Thread.sleep(2000);
		}
	}

}

public 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;
	}

}

public 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;
	}

	// 当多个线程修改同一个共享数据时，将涉及数据安全问题
	@Override
	public void run() {
		// 账户余额大于取钱数目时
		if (account.getBalance() >= drawAmount) {
			System.out.println(getName() + "取钱成功，吐出钞票：" + drawAmount);

			// 修改余额
			account.setBalance(account.getBalance() - drawAmount);
			System.out.println("余额为：" + account.getBalance());
		}
		else {
			System.out.println(getName() + "取钱失败，余额不足.");
		}
	}

}

public class DrawTest {

	public static void main(String[] args) {
		// 创建一个账户
		Account account = new Account("2017", 1000);

		// 模拟两个线程对同一个账户取钱
		new DrawThread("张晓明", account, 800).start();
		new DrawThread("张大明", account, 800).start();
	}
}

synchronized (obj) {
  ...// 此处的代码就是同步代码块
}

public 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;
	}

	// 当多个线程修改同一个共享数据时，将涉及数据安全问题
	@Override
	public void run() {
		// 加锁->修改->释放锁
		synchronized (account) {
			// 账户余额大于取钱数目时
			if (account.getBalance() >= drawAmount) {
				System.out.println(getName() + "取钱成功，吐出钞票：" + drawAmount);

				// 修改余额
				account.setBalance(account.getBalance() - drawAmount);
				System.out.println("余额为：" + account.getBalance());
			}
			else {
				System.out.println(getName() + "取钱失败，余额不足.");
			}
		}// 同步代码块结束，该线程释放同步锁
	}

}

public 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;
	}

	public synchronized void draw(double drawAmount) {
		// 账户余额大于取钱数目时
		if (balance >= drawAmount) {
			System.out.println(Thread.currentThread().getName() + "取钱成功，吐出钞票：" + drawAmount);

			try {
				Thread.sleep(1);
			}
			catch (InterruptedException e) {
				e.printStackTrace();
			}

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

}

public class SyndrawThread extends Thread {

	private Account account;// 用户账户

	private double drawAmount;// 取钱金额

	public SyndrawThread(String name, Account account, double drawAmount) {
		super(name);// 线程名称
		this.account = account;
		this.drawAmount = drawAmount;
	}

	@Override
	public void run() {
		account.draw(drawAmount);
	}

}

public class SyndrawTest {

	public static void main(String[] args) {
		// 创建一个账户
		Account account = new Account("2017", 1000);

		// 模拟两个线程对同一个账户取钱
		new SyndrawThread("张晓明", account, 800).start();
		new SyndrawThread("张大明", account, 800).start();
	}
}

public class AccountLock {

	// 定义锁对象
	private final ReentrantLock lock = new ReentrantLock();

	private String accountNo;// 账户编号

	private double balance;// 余额

	public AccountLock(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;
	}

	// 提供一个线程安全的draw()方法来完成取钱操作
	public void draw(double drawAmount) {
		// 加锁
		lock.lock();

		try {
			// 账户余额大于取钱数目
			if (balance >= drawAmount) {
				System.out.println(Thread.currentThread().getName() + "取钱成功，吐出钞票：" + drawAmount);

				try {
					Thread.sleep(1);
				}
				catch (InterruptedException e) {
					e.printStackTrace();
				}

				balance -= drawAmount;
				System.out.println("余额为：" + balance);
			}
			else {
				System.out.println(Thread.currentThread().getName() + "取钱失败，余额不足.");
			}
		}
		finally {
			// 修改完成，释放锁
			lock.unlock();
		}
	}

}

public class AccountLockThread extends Thread {

	private AccountLock accountLock;

	private double drawAmount;

	public AccountLockThread(String name, AccountLock accountLock, double drawAmount) {
		super(name);
		this.accountLock = accountLock;
		this.drawAmount = drawAmount;
	}

	public double getDrawAmount() {
		return drawAmount;
	}

	public void setDrawAmount(double drawAmount) {
		this.drawAmount = drawAmount;
	}

	@Override
	public void run() {
		accountLock.draw(drawAmount);
	}

}

public class AccountLockTest {

	public static void main(String[] args) {
		AccountLock al = new AccountLock("2016", 1000);
		new AccountLockThread("刘忠", al, 600).start();
		new AccountLockThread("张忠", al, 600).start();
	}

}

//当两个线程相互等待对方释放同步监视器时就会发生死锁
public class DeadLock implements Runnable {

	A a = new A();

	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");

		// 调用A对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

	@Override
	public void run() {
		Thread.currentThread().setName("副线程");

		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入副线程之后");
	}

	public static void main(String[] args) {
		DeadLock d1 = new DeadLock();

		// 以d1为target启动新线程
		new Thread(d1).start();

		// 调用init方法
		d1.init();
	}

}

class A {

	public synchronized void foo(B b) {
		System.out.println("当前线程名:" + Thread.currentThread().getName() + " 进入A实例的foo()方法");
		try {
			Thread.sleep(200);
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("当前线程名:" + Thread.currentThread().getName() + " 企图调用B实例的last()方法");
		b.last();
	}

	public synchronized void last() {
		System.out.println("进入A类的last()方法内部");
	}
}

class B {
	public synchronized void bar(A a) {
		System.out.println("当前线程名:" + Thread.currentThread().getName() + " 进入B实例的bar()方法");
		try {
			Thread.sleep(200);
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("当前线程名:" + Thread.currentThread().getName() + " 企图调用A实例的last()方法");
		a.last();
	}

	public synchronized void last() {
		System.out.println("进入B类的last()方法内部");
	}
}

public class ThreadPoolTest implements Runnable {

	@Override
	public void run() {
		// 局部变量，多个线程不共享；共享实例变量
		for (int i = 0; i < 20; i++) {
			System.out.println("run：" + Thread.currentThread().getName() + " " + i);
		}
	}

	public static void main(String[] args) {
		// 创建一个具有固定线程数（6）的线程池
		ExecutorService pool = Executors.newFixedThreadPool(6);

		ThreadPoolTest tpt = new ThreadPoolTest();
		// 向线程池中提交三个线程
		pool.submit(tpt);
		pool.submit(tpt);
		pool.submit(tpt);

		// 关闭线程池
		pool.shutdown();
	}

}

package threadlocal;

public class ThreadLocalTest {

	public static void main(String[] args) {
		// 为主线程设置名称，默认名称为main
		Thread.currentThread().setName("main：");

		Account at = new Account("王初始");

		for (int i = 0; i < 20; i++) {
			if (i == 6) {
				at.setName(Thread.currentThread().getName());
			}
			System.out.println(at.getName() + " 账户的i值：" + i);
		}

		// 启动两个子线程，共享同一个Account
		new MyTest(at, "first：").start();
		new MyTest(at, "second：").start();

	}

}

class Account {

	// 定义一个ThreadLocal类型的变量，该变量将是一个线程局部变量，每个线程都会保留该变量的一个副本
	private ThreadLocal<String> name = new ThreadLocal<String>();

	// 定义一个初始化的name成员变量的构造器
	public Account(String str) {
		this.name.set(str);
		System.out.println("---" + this.name.get());
	}

	public String getName() {
		return name.get();
	}

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

}

class MyTest extends Thread {

	// 定义一个Account类型的成员变量
	private Account account;

	public MyTest(Account account, String name) {
		super(name);
		this.account = account;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			if (i == 6) {
				account.setName(Thread.currentThread().getName());
			}
			System.out.println(account.getName() + " 账户的i值：" + i);
		}
	}
}