Java 线程状态

 

状态：

创建线程的方法：

public class NewThread implements Runnable{
    @Override
    public synchronized void run(){
    	while(true){ 
    		try {
				//Thread.sleep(100);
    			wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
    		System.out.println("线程运行中...");
    	}
    }
    public static void main(String[] args) {
    	NewThread n=new NewThread();
    	
    	//初始化状态
		Thread thread =new Thread(n); //创建线程,并执行线程任务

		thread.start();  //启动线程
		while(true){
			synchronized (n) {
				System.out.println("主线程执行了....");
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				n.notifyAll();
			}
		}
	}
}

　　

public class Demo1 extends Thread{
	public Demo1(String name){
		super(name);
	}
	
    @Override
    public void run() {
    	// while(true){
    	while(!interrupted()){  //中断线程的推荐用法
    		 System.out.println(getName()+"线程执行了。。");
    		 try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
    	 }
    }

     public static void main(String[] args) {
		Demo1 demo1=new Demo1("first-thread");
		Demo1 demo2=new Demo1("second-thread");
		
		//守护线程
		//demo1.setDaemon(true);
		//deom2.setDaemon(true);
		
		demo1.start();
		demo2.start();
		
		//中断线程
		//demo1.stop();
		demo1.interrupt();
//		try {
//			Thread.sleep(2000);
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}
	}
}

　　

public class Demo3 {
   public static void main(String[] args) {
	   //匿名内部类，只是用一次
	   new Thread(){
		   public void run(){
			   System.out.println("thread start...");
		   };  
	   }.start();
	   
	   new Thread(new Runnable() {
		@Override
		public void run() {
           System.out.println("thread start...");
		}
	}).start();
	   
	   //两个同时使用
	   new Thread(new Runnable() {
		@Override
		public void run() {
			System.out.println("runnable");
		}
	 }){
		   public void run(){
			   System.out.println("sub");
		   };
	   }.start();
   } 
}

　　

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

//线程的返回值类型
public class Demo4 implements Callable<Integer>{

	public static void main(String[] args) throws Exception  {
		Demo4 demo4=new Demo4();
		FutureTask<Integer> task=new FutureTask<>(demo4);
		Thread t=new Thread(task);
		t.start();
		task.get();
		System.out.println("我先干点别的。。。。");
		Integer result=task.get();
		System.out.println("线程执行的结果为："+result);
	}
	@Override
	public Integer call() throws Exception {
		System.out.println("正在进行紧张的计算");
		Thread.sleep(300);
		return 1;
	}
}

　　定时器：

import java.util.Timer;
import java.util.TimerTask;

public class Demo5 {
    public static void main(String[] args) {
		Timer timer=new Timer();
		timer.schedule(new TimerTask() {
			
			@Override
			public void run() {
                //实现定时任务
				System.out.println("timertask is run");
			}
		},0,1000);
	}
}

　　线程池：

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo6 {
    public static void main(String[] args) {
    	//固定容量的线程池
		//Executor threadPool=Executors.newFixedThreadPool(10);
		//ExecutorService threadPool=Executors.newFixedThreadPool(10);
    	ExecutorService threadPool=Executors.newCachedThreadPool();
    	
		for(int i=0;i<10;i++){
			threadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName());
				}
			});
		}
		threadPool.shutdown();
	}
}

　　spring使用线程：

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@ComponentScan("com.roocon.thread.t1")  //扫描的包
@EnableAsync
public class Config {

}

　　

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service   //交给spring管理
public class DemoService {
	@Async  //异步调用的注解
	public void a() {
		while (true) {
			System.out.println("a");
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	public void b() {
		while (true) {
			System.out.println("b");
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

　　

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
		AnnotationConfigApplicationContext ac=new 
				AnnotationConfigApplicationContext(Config.class);
		DemoService ds=ac.getBean(DemoService.class);
		ds.a();
		ds.b();
	}
}

　　使用lambda表达式：

import java.util.Arrays;
import java.util.List;

public class Demo7 {
	public static void main(String[] args) {
		List<Integer> value=Arrays.asList(10,20,30,40);
		int res=new Demo7().add(value);
		System.out.println("计算结果："+res);
	}
   public int add(List<Integer> values){
	   //打印集合中的值  并行执行
	   //values.parallelStream().forEach(System.out::println);
	   //不是并行执行
	   //values.stream().forEach(System.out::println);
	   //并行执行排序
	   values.parallelStream().forEachOrdered(System.out::println);
	   return 0;
	   //并发的流
	   //return values.parallelStream().mapToInt(a->a).sum();
   }
}

　　线程带来的风险：

1.线程安全问题

2.活跃性问题（死锁、饥饿、活锁）

3.性能问题

饥饿与公平

同时启动三个线程执行会有重复性数据：（与字节码有关）

public class Sequence {
    private int value;
    public int getNext(){
    	value=value+1;
    	return value++;
    }
    public static void main(String[] args) {
    	Sequence sq=new Sequence();
    	//一个执行
//		while(true){
//			System.out.println(sq.getNext() );
//		}
    	new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					System.out.println(
							Thread.currentThread().getName()+""+
					sq.getNext());
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}).start();
    	new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					System.out.println(
							Thread.currentThread().getName()+""+
					sq.getNext());
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}).start();
    	new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					System.out.println(
							Thread.currentThread().getName()+""+
					sq.getNext());
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}).start();
	}
}

　　解决方法：让方法变成同步方法。

  public synchronized int getNext(){
        return value++;
    }

　　线程安全问题：

1.多线程环境下

2.多个线程共享一个资源

3.对资源进行非原子性操作

 内置锁：每个对象都可以用同步的锁   synchronized  放在普通方法上，内置锁就是当前类的实例。修饰静态方法，内置锁是当前Class字节码对象，修饰代码块。

互斥锁：一个线程进来，另一个线程就不能就来，保证了原子性

任何对象都可以作为锁，锁的信息又存在对象的什么地方呢？

存在对象头中

对象头中的信息包括：

1.Mark Word

2.Class Metadata Address

3.Array Length

偏向锁：每次获取锁和释放锁会浪费资源

很多情况下，竞争锁，不是由多个线程，而是由一个线程在使用。

只有一个线程在访问同步代码块的场景

轻量级锁：自旋，多个线程可以同时

重量级锁：只能等当前线程执行完了，其他线程才能进去。

锁重入：使用同一个对象才能锁的住，不同的对象是锁不住的。 

public class Demo {
	public synchronized void a(){
		System.out.println("a");
		//b();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	public synchronized void b(){
		System.out.println("b");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
    public static void main(String[] args) {
    	 //Demo demo=new Demo();
    	Demo demo1=new Demo();
    	Demo demo2=new Demo();
		new Thread(new Runnable() {
			@Override
			public void run() {
				demo2.a();
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				demo1.b();
			}
		}).start();
	}
}

　　自旋锁的应用：

import java.util.Random;

//多个线程执行完毕后，打印一句话，结束
public class Demo2 {
    public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"执行开始....");
				
				try {
					Thread.sleep(new Random().nextInt(2000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"执行完毕了...");
			}
		}).start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"执行开始....");
				
				try {
					Thread.sleep(new Random().nextInt(2000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"执行完毕了...");
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"执行开始....");
				
				try {
					Thread.sleep(new Random().nextInt(2000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"执行完毕了...");
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"执行开始....");
				
				try {
					Thread.sleep(new Random().nextInt(2000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"执行完毕了...");
			}
		}).start();
		
		while(Thread.activeCount()!=1){
			//自旋
		}
		//if(Thread.activeCount()==1)//活动线程的数量
		    System.out.println("所有的线程执行完毕了");
		
	}
}

　　死锁：当一个线程永远的持有一把锁，并且其他线程尝试获取这把锁，也就发生了死锁

public class Demo3 {
    private Object obj1=new Object();
    private Object obj2=new Object();
    
    public void a(){
    	synchronized (obj1) {
    		try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			synchronized (obj2) {
				System.out.println("a");
			}
		}
    }
    public void b(){
    	synchronized(obj2){
    		try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    		synchronized (obj1) {
    			System.out.println("b");
			}
    	}
    }
    public static void main(String[] args) {
    	Demo3 demo3=new Demo3();
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				demo3.a();
			}
		}).start();
        new Thread(new Runnable() {
			
			@Override
			public void run() {
				demo3.b();
			}
		}).start();
	}
}

　　

单例中出现线程安全问题，懒汉和饿汉方式：

public class Singleton {
	//私有化构造方法，不让new
    private Singleton(){
    	
    }
    //饿汉式，创建的时候实例化（没有线程安全性问题）
    private static Singleton instance=new Singleton();
    
    public static Singleton getInstance(){
    	return instance;
    }
    
     //出现线程安全性问题的条件 
    //多线程的环境下
    //必须有共享资源
    //对资源进行非原子性操作
}

　　

public class Main {
   public static void main(String[] args) {
	Singleton s1=Singleton.getInstance();
	Singleton s2=Singleton.getInstance();
	Singleton s3=Singleton.getInstance();
	Singleton s4=Singleton.getInstance();
	
	System.out.println(s1);
	System.out.println(s2);
	System.out.println(s3);
	System.out.println(s4);
   }
}

　　

public class Singleon2 {
   private Singleon2(){}
   //懒汉式
   private static volatile Singleon2 instance;
  // public static Singleon2 getInstance(){
   public static synchronized Singleon2 getInstance(){  //synchronized没有性能保证
	   //自旋  while(true) 
	   if(instance ==null){
//		   try {
//			Thread.sleep(100);
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}
		   synchronized(Singleon2.class){ //锁住有问题的代码
			   if(instance==null){
				   instance =new Singleon2();  //双重检查加锁，还有指定重排序的问题
				   //申请一块空间 1.
				   //在这块空间中实例化对象2.
				   //instance的引用指向这块空间地址3.
				   //但是不一定这样执行，这就引发指令重排序
				   //volatile 不会出现指令重排序
			   }
		   }
	   }
	   return instance;
   }
}

　　

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadMain {
    public static void main(String[] args) {
    	//固定线程池
		ExecutorService threadPool=
				Executors.newFixedThreadPool(20);
		for(int i=0;i<20;i++){
			threadPool.execute(new Runnable() {
				
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()
							+":"+Singleon2.getInstance());
				}
			});
		}
		threadPool.shutdown();
	}
}