j2se-------进程与线程

多进程：在操作系统中能（同时）运行多个任务（程序）

多线程：在同一应用程序（进程）中有多个顺序流（同时--从宏观上看，从微观上看叫交错执行）执行


windows 是多进程的操作系统，也就是说在同一个时间段内可以打开word编写东西，而且也可以打开暴风影音看电影

所以进程就是：正在运行的程序集合体（在有多线程情况下）。。。。

线程体会： 我们在编写word的时候，经常word会给我们写错的字画上一个小红下划线，那么在这个进程之上 我们可以如入文字，而且word会同时检测错误。

在同一个进程上面并行运行多个东西，他是对进程的进一步划分，所以如果一个进程消失了，那么在他上面的线程就消失了，在多线程任务中所有的程序共享系统资源。

多线程上同时有多个程序在运行。 一个线程对应一个程序哈，所谓程序在执行意思是：程序区段（代码段）正在命令cpu做事情

注意：在Thread源码中的start方法，会调用一个private native void start0();的方法，
而native关键字表示是一个由java调用本机操作系统函数的关键字，在java中，运行java程序调用本机的操作系统的函数以完成特定的功能

这证明：如果现在想要实现多线程，则肯定需要操作系统的支持，因为多线程操作中牵涉到一个抢占cpu的情况，要等待cpu进行调度，那么这一点肯定需要操作系统的底层支持，所以使用了native调用本机的系统函数

Thread和Runnable的区别：
   1。使用Thread类在操作多线程的时候无法达到资源共享的目的，而使用Runnable接口实现的多线程操作可以实现资源共享。。。。只共享实例变量哈，局部变量还是不共享哈
    2。单继承有开发局限，因为你继承了Thread你就不能继承其他的类了

   其原因是，如果使用Thread ,那么多线程的话会要 new出来多个Thread
   而使用Runnable的话   public class MyThread implements Runnable{ int i = 0...}
   MyThread m = new MyThread(); 
   new Thread(m).start();
   new Thread(m).start();
   new Thread(m).start(); //这样同一个类被变成三个线程启动，那么里面的实例变量当然也会被共享  



创建状态： 准备好了一个多线程的对象，Thread t = new Thread();
就绪状态：调用了start()方法，等待cpu进行调度
运行状态： 执行run()方法
阻塞状态： 暂时停止执行，可能将资源交给其他线程使用

就像一个运动员跑不一样，来到跑场（创建），准备跑步（就绪），跑步（运行），摔跤（阻塞）。。
-----------------------------------------------------------------------------------Name
在Thread类中，可以通过getName()方法取得线程名称，可以setName()设置线程名称，
线程的名称一般在启动线程前设置，但也允许为已经允许的线程设置名称，允许两个Thread对象有相同的名称
如果没有设置名称，那么系统会自动分配一个名称

类比： 一个人在出生的时候给了一个名字，但是这个人活到60岁想改名称，这肯定很麻烦，
线程的名字在线程启动之前设置，避免重名



------------------------------------------------------------------------------------
Thread.currentTHread();方法可以取得当前正在运行的线程对象,如果有多个线程的话，那么我们可以写这个代码放到线程之中，就可以把线程相区别
public class MyThread implements Runnable{ int i = 0.；
   public void run(){
       System.out.println(Thread.currentThread().getName());
   }
}

public class Test{
   public static void main(String[] args){
        MyThread m = new MyThread();
        new Thread(m,"我是线程").start(); //创建并就绪线程
        m.run();        //在主方法里面启动线程
   }
}



每当java程序执行的时候，实际上会启动一个JVM,每个JVM实际就是操作系统中启动了一个进程（java.exe）,而主方法是以线程的形式启动的，所以当一个java运行的时候至少启动两个线程，一个是主线程，一个垃圾回收期（GC）

t.isLive(); //表示是否t线在start()之后，在destory()之前，就算他是在阻塞状态没得到cpu他也是存活的，如果没start()那么不算存活，类比就是：是否这个运动员在比赛中。。。


t.join();//线程强制运行，当这个方法被调用，那么这个t小子就开始插队到第一个，并告诉cpu，你得先把我的命令全部执行完后，你再去交叉调用别人。。。

public static void main(String[] args){
    MyThread mt = new MyThread();
    Thread t = new Thread(mt);
    t.start();
    for(int i=0;i<50;i++){
        if(i>10){
            try{
               t.join(); //这里是主方法让t小子插队的，也就是我主方法排在t的后面去执行后面的代码,我们可以把这个东西想象成为 加入队列顺序执行，当t执行完成之后再启动并行执行
            }catch(InterruptedException e){
            }
         System.out.println("main"+i);
        }
    }
}


-------------------------------------------------------------------------Thread.sleep(500);

线程休眠 ： 那个线程调用这个方法，就相当于那个线程问Thread类要一个床，我们可以把这句话理解为： Thread大主管，请给俺一个床，我睡500毫秒即可，注意他睡醒之后不一定立刻得到cpu哦

------------------------------------------------------------------------t.interrupt(); //打断t的休眠，也就是叫醒t,如果t在睡觉，那么叫醒他的话会发生状态转换，会抛异常，如果t本身没有睡觉，那么叫不叫他都是醒的，这个时候当然不会发送状态转换异常啦



class MyThread implements Runnable{
   public void run(){
       System.out.println("1.进入run()方法");
       try{
           Thread.sleep(1000);
           System.out.println("2,已经完成了休眠");  //try catch的作用是当try里面的东西执行出错了之后由catch里面的代码代替try中的错误代码及其以后的代码执行，所以有了try catch之后，程序报错也和没报错一样
       }catch(InterruptedException e){
            System.out.println("3,休眠被终止");
            return;  //这个意思是如果报错了，那么不执行下面的代码了
       }
       System.out.println("4.run()方法正常结束");
   }
}


public class Test{
   public static void main(String[] args){
       MyThread mt = new MyThread();
       Thread t = new Thread(mt);
       t.start();
       try{
          Thread.sleep(2000);
       }catch(Exception e){
          System.out.println("3,休眠终止了");
        }
        t.interrupt();
   }
}

--------------------------------------------------------------------------后台线程，也就是能够脱离进程的线程

在java中，只要一个程序没有执行完（一个线程在运行），则整个java进程不会消失，所以此时可以设置一个后台线程，这样即使java 进程结束了，此后台线程依然会继续执行
后台线程是为其他的线程提供服务的，又称为守护进程，他牛逼就牛逼在JVM退出了他还会执行，也就是说他是直接脱离JVM的，不归JVM管的东西


------------------------------------------------------------------------

线程的优先级

t1.setPriority(Thread.MIN_PRIORITY) ; //优先级最低 值为1
t2.setPriority(Thread.MAX_PRIORITY) ; //优先级最高  值为5
t3.setPriority(Thread.NORM_PRIORITY) ; //优先级普通，也就是中等，值为10
t1.start();
t2.start();
t3.start();
优先级越高越有可能被先执行，但是也会别抢占哦，只是他的机会多些
注意： main()方法的优先级是 普通优先级。。。

------------------------------------------------------------------------------线程的礼让

Thread.yield(); //和join不同的是，他只是让调用它的线程让出cpu,并不指定让出spu后指定谁来执行


-----------------------------------------------------------------------
同步与死锁

什么情况下需要同步？
条件一：此数据时在线程间共享的数据。
条件二：当共享数据正在被写入的时候可能被另一个线程读到 或者 当共享数据正在被读到的时候可能被另一个线程改写

所以如果共享数据牵涉到被改变的时候就要同步
那么在java中，怎样的数据时共享数据呢？
第一： static标识的数据
第二:一个实现了Runnable接口的类的实例变量，也就是说同一个实例别放到多个线程中。。。看下面代码
第三： 直接传递同一个对象给多个线程，那么这些线程就有对这个对象的共享资格了，可以见下面的生产者和消费者例子
class MyThread implements Runnable{
  private int ticket = 5;
   public void run(){
      for(int i=0;i<100;i++){
         if(ticket > 5){ //这是读取共享数据
           try{
             System.out.println("出售第ticket ="+ticket);
              ticket -- ; //这是改写共享数据
               Thread.sleep(1000);
           }catch(InterruptedException e){}
           
         }
   }
}
public class Test{
   public static void main(String[] args){
       MyThread m = new MyThread();
       Thread t1 = new Thread(m); //把这个东西放入了两个线程中间，显然就会对共享数据进行操作
       Thread t2 = new Thread(m);
        t1.start();
        t2.start();
   }
}

上面的代码会出现被修改的情况。。。。下面改进，使用同步代码块
class MyThread implements Runnable{
  private int ticket = 5;
   public void run(){
      for(int i=0;i<100;i++){
       synchronized(this){ //同步时为了把这一系列的操作当成一个原子操作
         if(ticket > 5){ //这是读取共享数据
              try{
                System.out.println("出售第ticket ="+ticket);
                 ticket -- ; //这是改写共享数据
                  Thread.sleep(1000);
              }catch(InterruptedException e){}
          }//if
       }
   }
}


同步真的安全吗？
过多的同步可能引起死锁
故事： 张三想要李四的画，李四想要张三的书，于是张三对李四说：你把你的画给我，我就给你我的书，李四对张三说：你把你的书给我，我就给你我的画。。。于是。。。死锁出现了

class Zhangsan{
	public void say(){
		System.out.println("张三对李四说：”你给我画，我就给你书“");
	}
	public void get(){
		
		System.out.println("张三得到画了");
	}
}

class Lisi{
	public void say(){
		System.out.println("李四对张三说：”你给我书，我就给你画“");
	}
	public void get(){
		System.out.println("李四得到书了");
	}
}

class ThreadDeadLock implements Runnable{
	private static Zhangsan zs = new Zhangsan();
	private static Lisi ls = new Lisi();
	public boolean isZhangsanFirst = true;
	public void run(){
		if(isZhangsanFirst){
			synchronized (zs) { //不让别的线程来问zs有没有书，因为这里zs,ls都是共享变量
				 zs.say();
				 try{
					 Thread.sleep(500);
				 }catch(InterruptedException e){}
				synchronized(ls){ //不让别的线程去拿李四的书
					zs.get();
				}
			}
		}else{
			synchronized (ls) { 
				 ls.say();
				 try{
					 Thread.sleep(500);
				 }catch(InterruptedException e){}
				synchronized(zs){  //这里告诉我们两层嵌套很容易死锁
					ls.get();
				}
			}
		}
	}
	
	public static void main(String[] args){
		ThreadDeadLock zsFirst = new ThreadDeadLock();
		ThreadDeadLock lsFirst = new ThreadDeadLock();
		zsFirst.isZhangsanFirst = true;
		lsFirst.isZhangsanFirst = false;
		Thread t1 = new Thread(zsFirst);
		Thread t2 = new Thread(lsFirst);
	}
}

下面对synchronized(ls){}来做几点说明
synchronized可以用在方法上，一般不用，因为如果是放在方法上的话，那么默认的锁是这个方法所在类的实例，如果我们对这个类new了两个的话，那么根本锁不住
同理synchronized(ls){}能达到锁的目的，是因为这个ls虽然是new出来的，但是是static的，也就是说只会被new一次
还有一种解决方案是synchronized(ls.getClass()){} 因为ls这个对象的类的字节码只有一份。。。。。
或者根据String对象可以在对象池的原理，还可以这样
synchronized("a"){} 呵呵，玩玩而已啦
总之：我们要保证钥匙只有一份就可以了