Biegral Blog

public class RunnableDemo1 {
	public static void main(String[] args) {
		RunnableDemo r1 = new RunnableDemo();
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r1);

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

class RunnableDemo implements Runnable {
	 int i = 0;
	/**
	 * 线程要执行的代码
	 */
	public void run() {
		for (; i < 10; i++) {
			// Thread.currentThread().getName()可以获取当前线程名称
			System.out.println(Thread.currentThread().getName() + "==>" + i);
		}
	}
}

public class CallableDemo1 {
	public static void main(String[] args) {
		//注意Callable需要泛型支持
		FutureTask<Boolean> ft1 = new FutureTask<>(new CallableDemo(1));
		FutureTask<Boolean> ft2 = new FutureTask<>(new CallableDemo(0));
		FutureTask<Boolean> ft3 = new FutureTask<>(new CallableDemo(2));
		Thread t1 = new Thread(ft1);
		Thread t2 = new Thread(ft2);
		Thread t3 = new Thread(ft3);

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

		// 获取线程返回值
		try {
			//get方法获取返回值时候会导致主线程阻塞，直到call()结束并返回为止
			System.out.println(ft1.get());
			System.out.println(ft2.get());
			System.out.println(ft3.get());
		} catch (Exception e) {
			//可以catch住线程体里的异常
			e.printStackTrace();
		}
	}
}

class CallableDemo implements Callable<Boolean> {
	int flag;
	int i = 0;

	public CallableDemo(int flag) {
		this.flag = flag;
	}

	/**
	 * 线程要执行的代码
	 */
	public Boolean call() throws Exception {
		for (; i < 10; i++) {
			// Thread.currentThread().getName()可以获取当前线程名称
			System.out.println(Thread.currentThread().getName() + "==>" + i);
		}

		if (flag == 1) {
			return true;
		} else if(flag == 0){
			return false;
		}else {
			throw new Exception("哇咔咔咔");
		}
	}
}

public class ThreadDemo1 {
	public static void main(String[] args) {
		//创建三个线程对象
		ThreadDemo t1 = new ThreadDemo();
		ThreadDemo t2 = new ThreadDemo();
		ThreadDemo t3 = new ThreadDemo();
		//启动三个线程对象
		t1.start();
		t2.start();
		t3.start();
	}
}

class ThreadDemo extends Thread{
	/**
	 * 线程要执行的代码
	 */
	public void run() {
		for(int i = 0 ; i < 10 ; i ++) {
			//this.getName()可以获取当前线程名称
			System.out.println(this.getName()+"==>"+i);
		}
	}
}

public class DaemonDemo1 {
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			if (i == 5) {
				try {
					//暂停5秒
					Thread.sleep(5 * 1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}
}

public class YieldDemo1 {
	public static void main(String[] args) {
		YieldThread r = new YieldThread();
		new Thread(r).start();
		new Thread(r).start();
	}
}

class YieldThread implements Runnable {
	public void run() {
		for (int i = 0; i < 100; i++) {
			if(i==50) {
				Thread.yield();
			}
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
}

public class PriorityDemo {
	public static void main(String[] args) {
		PriorityThread t1 = new PriorityThread();
		PriorityThread t2 = new PriorityThread();
		
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(Thread.MIN_PRIORITY);
		
		t1.start();
		t2.start();
                System.out.println("得到线程优先级t1="+t1.getPriority());
		System.out.println("得到线程优先级t2="+t2.getPriority());
	}
}
class PriorityThread extends Thread{
	public void run(){
		for(int i = 0 ; i < 100 ; i ++){
			System.out.println(" "+getName()+":"+i);
		}
	}
}

public class DaemonDemo1 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new DaemonThread());
		//设置为后台线程
		t1.setDaemon(true);
		t1.start();
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
		//后台线程还没有完全运行完就会死掉，因为主线程先死了。
		//查看是否为后台线程
		System.out.println(t1.isDaemon());
		System.out.println(Thread.currentThread().isDaemon());
	}
}
class DaemonThread implements Runnable{
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
}

public class ThreadLocalDemo1 {
	public static void main(String[] args) {
		Person p = new Person();
		//启动两个线程，两个线程共享person对象
		new ThreadDemo1(p).start();
		new ThreadDemo2(p).start();
	}
}

class ThreadDemo1 extends Thread {
	Person p;

	public ThreadDemo1(Person p) {
		this.p = p;
	}

	public void run() {
		System.out.println(this.getName() + " start " + p.getName());
		// 将线程局部变量赋值
		p.setName("张三");
		System.out.println(this.getName() + " end " + p.getName());
	}
}

class ThreadDemo2 extends Thread {
	Person p;

	public ThreadDemo2(Person p) {
		this.p = p;
	}

	public void run() {
		System.out.println(this.getName() + " start " + p.getName());
		// 将线程局部变量赋值
		p.setName("李四");
		System.out.println(this.getName() + " end " + p.getName());
	}
}

class Person {
	// 定义线程局部变量，每个线程都会保留该变量的一个副本，多个线程之间并不互相印象。
	private ThreadLocal<String> name = new ThreadLocal<>();

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

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

public class DeadLockDemo1 {
	public static void main(String[] args) {
		A a = new A();
		B b = new B();
		
		/**
		 * 线程1调用获得b对象的监视器锁，线程被暂停了，但还没有释放。
		 * 线程2调用并获得a对象的监视器锁，线程被暂停了，但还没有释放。
		 * 线程1恢复并调用a对象的监视器锁，但a对象的锁被线程2持有还没有释放，因此被阻塞。
		 * 线程2恢复并调用b对象的监视器锁，但b对象的锁被先吃1持有还没有释放，并且线程1还在等待线程2释放a对象的锁，
		 * 最后导致两个线程互相等待对方释放锁，因此出现死锁。
		 */
		
		//线程1
		new Thread(new Runnable() {
			public void run() {
				//
				b.one(a);
			}
		}).start();
		
		//线程2
		new Thread(new Runnable() {
			public void run() {
				//
				a.one(b);
			}
		}).start();
	}
}

class A {
	public synchronized void one(B b) {
		System.out.println(Thread.currentThread().getName()+" 进入A one");
		
		try {
			Thread.sleep(1*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+" 调用B two");
		b.two();
	}

	public synchronized void two() {
		System.out.println("进入A two");
	}
}

class B {
	public synchronized void one(A a) {
		System.out.println(Thread.currentThread().getName()+" 进入B one");
		try {
			Thread.sleep(1*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+" 调用A two");
		a.two();
	}
	
	public synchronized void two() {
		System.out.println("B two");
	}
}

public class ConditionDemo1 {
	public static void main(String[] args) {
		Bank b = new Bank();
		for (int i = 0; i < 10; i++) {
			new Thread(new SaveThread(b)).start();
			new Thread(new GetThread(b)).start();
		}
	}
}

class Bank {
	Integer count = 10;
	String flag = "save";

	final Lock lock = new ReentrantLock();
	final Condition condition = lock.newCondition();

	public void save() {
		try {
			lock.lock();
			if ("get".equals(flag)) {
				condition.await();
			} else {
				count++;
				System.out.println(Thread.currentThread().getName() + " 存钱后，金额=" + count);
				flag = "get";
				condition.signalAll();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void get() {
		try {
			lock.lock();
			if ("save".equals(flag)) {
				condition.await();
			} else {
				count--;
				System.out.println(Thread.currentThread().getName() + " 取钱后，金额=" + count);
				flag = "save";
				condition.signalAll();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

class SaveThread implements Runnable {
	Bank bank;

	public SaveThread(Bank bank) {
		this.bank = bank;
	}

	public void run() {
		bank.save();
	}
}

class GetThread implements Runnable {
	Bank bank;

	public GetThread(Bank bank) {
		this.bank = bank;
	}

	public void run() {
		bank.get();
	}
}

public class BlockingQueueDemo {
	public static void main(String[] args) throws Exception {
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(2);
		new Producer(bq).start();
		new Producer(bq).start();
		new Producer(bq).start();
		new Consumer(bq).start();
		//生产者必须等待消费者消费后才能继续执行
	}
}
/**
 * 生产者
 */
class Producer extends Thread{
	BlockingQueue<String> bq ; 
	public Producer(BlockingQueue<String> bq) {
		this.bq = bq;
	}
	public void run() {
		for(int i = 0 ; i < 10 ; i++) {
			try {
				bq.put("a");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}finally {
				System.out.println(this.getName()+" 生产完毕"+bq);
			}
		}
	}
}
/**
 * 消费者
 */
class Consumer extends Thread{
	BlockingQueue<String> bq ; 
	public Consumer(BlockingQueue<String> bq) {
		this.bq = bq;
	}
	public void run() {
		for(int i = 0 ; i < 10 ; i++) {
			try {
				String take = bq.take();
				System.out.println(this.getName()+" 消费完毕 "+take+" "+bq);
			} catch (InterruptedException e) {
				e.printStackTrace();
			} 
		}
	}
}

public class ThreadGroupDemo1 {
	public static void main(String[] args) {
		//返回主线程所属的线程组
		ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();
		System.out.println("线程组名称 " + mainGroup.getName());
		System.out.println("线程组是否为后台线程 " + mainGroup.isDaemon());
		System.out.println("线程组的活动线程数目 " + mainGroup.activeCount());
		//创建新的线程组
		ThreadGroup newGroup = new ThreadGroup("newGroup");
		//设置后台线程
		newGroup.setDaemon(true);
		//设置线程优先级
		newGroup.setMaxPriority(Thread.MAX_PRIORITY);
		
		//设置异常处理

		new ThreadDemo(newGroup,"newThread1").start();
		new ThreadDemo(newGroup,"newThread2").start();
		//中断所有线程
//		newGroup.interrupt();
	}
}

class ThreadDemo extends Thread {
	public ThreadDemo(ThreadGroup threadGroup, String name) {
		super(threadGroup, name);
	}

	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(this.getName() + " " + i);
		}
	}
}