Java高并发代码篇

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/ld3205/article/details/83385762

一、创建线程： 

package com.dong.testThread;
/**
 * 
 * 1.线程的创建
 * 2.线程的方法
 * 
 * @author liuD
 *
 */
public class MultiThread {
	public static void main(String[] args) throws InterruptedException {
		//创建线程1，使用实现Runnable接口的类，使用lambda表达式；
		Thread  trl =new Thread(() -> System.out.println(Thread.currentThread().getName()+ " thread start..."));
		trl.start();
		//使用实现Runnable接口的类，不使用lambda表达式；
		Thread tr = new Thread(new runnableExam());
		tr.start();
		//创建线程2，使用继承了Thread类来创建线程,使用默认的run()
		Thread th = new Thread();
		th.start();
		//创建线程3，使用继承了Thread类的实例做参数。使用重写的run()
		Thread th2 =new Thread(new threadExam());
		
	}
}
class threadExam extends Thread{
	public void run() {
		System.out.println(Thread.currentThread().getName()+ " thread2 start ...");
	}
}
class runnableExam implements Runnable{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+ " thread start ...");
	}
	
}

二、线程的各个状态：

⑴新建： new()

package com.dong.testThread;
/**
 * 线程的new状态，即刚创建的线程
 * @author liuD
 */
public class TestNew {
	public static void main(String[] args) {
		//使用lambda创建线程；
		Thread t = new Thread(
				() -> System.out.println(Thread.currentThread().getName() + " will running")
				);
	}
}

⑵睡眠：sleep()

package com.dong.testThread;
/**
 * 测试Sleep功能，Sleep是让线程等待million毫秒后在执行
 * @author liuD
 */
public class TestSleep extends Thread{
	StringBuilder str = new StringBuilder();
	public static void main(String[] args) throws InterruptedException {
		Thread thread = new Thread(new TestSleep());
		long startTime  = System.currentTimeMillis();
		//⑵线程睡眠2秒
		thread.sleep(2000);
		long sleepTime  = System.currentTimeMillis();
		//注意这个结果不一定是2000
		System.out.println("thread has sleep "+ (sleepTime - startTime )+ " finish and will start ");
		thread.start();
	}
	public void run(){
		for(int i = 0 ;i< 10;i++) {
			str.append(".");
			System.out.println(str.toString());
		}
	}
}

⑶停止：stop()  （不建议使用）

package com.dong.testThread;
/**
 * 测试stop方法，stop方法会立刻释放锁资源，可能导致数据的不一致；
 * 
 * @author liuD
 *
 */
public class testStop {
	public static void main(String[] args) throws InterruptedException {
		new ReadObjectThread().start();
		while(true) {
			Thread t = new ChangeObjectThread();
			t.start();
			Thread.sleep(100);
			//调用stop()方法；
			t.stop();
		}
	}
}
class User{
	static int a = 0;
	static int b = 0;
	
	public static int getA() {
		return a;
	}
	public static int getB() {
		return b;
	}
	public static void setA() {
		a = a + 1;
	}
	public static void steB() {
		b = b + 1;
	}
}
class  ChangeObjectThread extends Thread{
	public  void run() {
		while(true) {
			synchronized(User.class) {
				User.setA();
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				User.steB();
			}
			Thread.yield();
		}
	}
}
class ReadObjectThread extends Thread{
	public void run() {
		while(true) {
			synchronized(User.class) {
				if(User.getA() != User.getB()) {
					System.out.println( "A = "+  User.getA() + " B = " + User.getB());
				}
			}
			Thread.yield();
		}
	}
}

⑷中断：interrupte()

package com.dong.testThread;
/**
 * 测试interrupte()方法
 * 当调用interrupte()方法，会给线程发送一个通知，告诉目标线程，该退出，至于如何退出，有目标线程自行决定；
 * interrrupte会通知目标线程中断，也就是设置中断标志位，中断标志位表示当前线程已经被中断了。
 * 刚调用interrupte()方法，相当于只设置了中断标志，但是这个中断不会发生任何作用；
 *如果想显示终止线程，可以使用Thread.currentThread().isInterrupted()方法，判断线程是否已经中断，可以显式中断线程；
 * @author liuD
 *
 */
public class TestInterrupt {
	public static void main(String[] args) throws InterruptedException {
		Thread thread = new Thread(new TThread());
		thread.start();
		thread.sleep(2000);
		//线程的中断不确定，设置了中断标志
		thread.interrupt();
		
		Thread tot = new Thread(new ToThread());
		tot.start();
		//线程的中断不确定，只是设置了中断标志
		tot.interrupt();
	}
}
class TThread implements Runnable{
	@Override
	public void run() {
		while(true) {
			//判断线程是否被中断，显式中断线程的执行；
			if(Thread.currentThread().isInterrupted()) {
				System.out.println(" Interrupted !!! ");
				break;
			}
			System.out.println("TT -----this is thread ...");
		}
		Thread.yield();
	}
}
class ToThread implements Runnable {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			System.out.println("ToT-----this is thread ...");
		}
	}
	
}

⑸等待：wait()   

⑹唤醒：notify()

package com.dong.testThread;
/**
 * wait()方法和notify()方法是在object类中定义的，
 * wait()让当然线程等待，进入锁对象的等待队列，直到有线程调用notify()方法，才会从等待队列中随机选择一个等待线程进行唤醒，
 * notify()方法从等待队列总随机选择一个线程进行唤醒；
 * @author liuD
 *
 */
public class TestWaitAndNotify {
	final static Object object = new Object();
	public static void main(String[] args) {
		Thread t1  = new Thread(new ToThreads());
		t1.start();
		Thread t2 = new Thread(new ToT2Threads());
		t2.start();
	}

static class ToThreads implements Runnable{
	@Override
	public void run() {
		synchronized (object) {
			System.out.println(System.currentTimeMillis()+ " : T1 start ");
			try {
				System.out.println(System.currentTimeMillis()+": T1 wait for object" );
				object.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(System.currentTimeMillis()+": T1 end !");
		}
	}	
}
static class ToT2Threads implements Runnable{
	public void run() {
		synchronized(object) {
			System.out.println(System.currentTimeMillis()+ " :T2 start notify one thread");
			object.notify();
			System.out.println(System.currentTimeMillis()+ " : T2 end! ");			
			try {
				Thread.sleep(2000);
			}catch(InterruptedException e) {}
		}
	}
	}
}

⑻谦让：yield

package com.dong.testThread;
/**
 * yield()方法会让当前线程让出Cpu的执行权，停止执行，从而重新争取cpu的资源，
 * @author liuD
 */
public class testYield {
	public static void main(String[] args) {
		Thread t1 = new Thread(new T1());
		Thread t2 = new Thread(new T2());
		//多个线程之间的执行是随机的，因此使用yield()方法，看不出来谦让的效果，所以设置一个高优先级和低优先级线程，来观察yield()的效果
		t1.setPriority(10);
		t2.setPriority(1);
		t1.start();
		//可以注释掉t1.yield()语句，来观察输出结果之间的变化；
		t1.yield();
		t2.start();
	}
}
class T1 implements Runnable{
	@Override
	public void run() {
		for(int i = 0;i<20;i++) {
			System.out.println("i \' am a brothers");
		}
	}
}
class T2 implements Runnable{
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int j =0;j<20;j++) {
			System.out.println("I \' am a sister");
		}
	}
}

⑼加入：join

package com.dong.testThread;
/**
 * 
 * yield()方法，它会阻塞当前线程，直到目标线程执行完毕，
 * @author liuD
 */
public class TestJoin {
	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(new joinThread());
		t1.start();
		//阻塞主线程，其他线程愿意等待t1线程执行完毕在执行,这里其他线程指主线程，如果没有t1.join(),则两个线程的输出语句就会随机输出		
		t1.join();
		for(int i = 0 ;i< 1000;i++) {
			System.out.println(Thread.currentThread().getName() +" : " + i);
		}
	}
}
class joinThread implements Runnable{
	public void run() {
		for(int j = 0 ;j < 3;j++) {
		System.out.println(Thread.currentThread().getName()+ " :  start start start " );
		}
	}
}

⑽运行：start

就是创建线程后，启动启动线程的方法，threadObject.start()方法；

部分代码参考《Java 高并发程序设计》  --葛一鸣，郭超 ，，由衷感谢此书作者为我们提供学习内容