线程

本章内容 ：
 1.线程的基本概念
 2.线程的创建和启动
 3.线程的调度和优先级
 4.线程的控制状态
 5.线程同步
基本概念：（是一个程序里面的不同执行路径）
 1.线程是一个程序内部的顺序控制流
 2.线程和进程的区别：
  1.每个进程都有独立的代码和数据空间（进行上下文），进程间的开销会有比较大的开销。
  2.线程可以看成是轻量级的进程，同一类线程共享代码和数据空间。
    有独立的运行栈和程序计数器（pc），线各一切换的开销小。
  3.多进程：在操作系统中能同时运行多个个顺序流同时执行。
 java的线程是通过java.lang.Thread类来实现的。
 VM启动时会有一个由主方法（public static void main(){}）所定义的线程。
 可以通过创建Thread的实例来创建新的线程。
 每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作。方法RUN叫做线程体。
 通过调用Thread类的start()方法来启动一个线程。（程序的顺序）
 
 进程是一个静态的概念。进程的运行表示主线程运行。
线程的创建和启动：
 第一种：定义线程类实现Runnable接口
         Runnable中只有一个方法：
         public void run():用以定义线程运行体。
         使用Runnable接口可以为多个线程提供共享的数据。
         在实现Runnable接口的类的run方法定义中可以使用Thread的静态方法。
         Public static Thread currentThread()获取当前线程的引用。
 第二种：可以定义一个Thread的子类并重写其Run方法
         然后再生成该类的实体对象。
 示例：区分这里的run（）和start方法，方法调用的线程启动程序执行的顺序：
      public static void main(String[] args) {
Runnable1 r1= new Runnable1();
Thread t1 = new Thread(r1);
t1.start();
for(int i=0;i<1000;i++){
System.out.println("main:" + "--------------");
}
}
}


class Runnable1 implements Runnable{
@Override
public void run() {
for(int i=0;i<1000;i++){
System.out.println("Runnable1:" + "=================");
}
}
}


线程的状态：
   创建===》start()====>就绪状态<===调度====>运行状态=====>终止
                          |                    　｜
                       阻塞解除              导致阻塞的事件
                          |                       |
                          <=======阻塞状态=========


线程控制的基本方法：
  isAlive() : 线程终止了就死了。
  getPriority(): 获得优先级。
  setPriority():  设置优先级。
  Thread.sleep():当前线程休息一会。（毫秒数）。
  join():调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行。//类似于方法调用
  yield():让出CPU，当前线程进入就绪队列等待调度。
  wait():当前线程进入对象的wait pool。
  notify(/notifyAll():唤醒对象的wait pool中的一个、所有等等线程。
 
示例程序1：
  public class DomeSeleep {


public static void main(String[] args) {
MyThread my  = new MyThread();
my.start();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
my.interrupt();
}
}
class MyThread extends Thread{
private boolean flag = true;
@Override
public void run() {
while(flag){
try {
sleep(1000);
System.out.println("=======" + new Date() + "========");
} catch (InterruptedException e) {
flag = false;
}
}
}
} 
示例程序2：
 public class Domejoin {


public static void main(String[] args) {
MyThread1 my1 = new MyThread1();
my1.start();
try {
my1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<100;i++){
System.out.println("I am a main");
}
}
}


class MyThread1 extends Thread{
@Override
public void run() {
for(int i=0;i<100;i++){
try {
sleep(100);
System.out.println("++++++++"+ new Date() + "++++++++");
} catch (InterruptedException e) {
return;
}
}
}
}


 示例：yeild（）方法：
public class Domeyield {


public static void main(String[] args) {
MyThread2 my21 = new MyThread2("my21");
MyThread2 my22 = new MyThread2("my222222222222");
my21.start();
my22.start();
}
}


class MyThread2 extends Thread{
public MyThread2(String s){
super(s);
}
@Override
public void run() {
       for(int i=0;i<100;i++){
      try {
sleep(100);
System.out.println( i + "=============" + getName());
if(i%10 == 0){
this.yield();
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
       }
}
}
  
  
  
线程的优先级：
 1.java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器线程的优先级决定应高度哪一个线程来执行。
 2.线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级是5.
   Thread.MIN_PRIORITY = 1
   Thread.MAX_PRIORITY = 10
   Thread.NORM_PRIORITY = 5
 使用下述线程方法获得设置线程的优先级.
   int getPriority()
   void setPriorty(int newPriorty)
 
线程同步：模拟现况：（取款操作）
在java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性，每个对象都
 对应于一个可称为“互斥锁”的标记，这个标记保证在任何一个时候，只能有一个对象访问该线程。
 解决办法 ： synchronized
 1.synchronized修饰方法时：表示该方法运行时，锁定当前对象。
 2.synchronized（this）{}锁定代码段
 示例程序：
  public class Domesychnriozied implements Runnable {


Timer timer = new Timer();
public static void main(String[] args) {
Domesychnriozied syc = new Domesychnriozied();
Thread t1 = new Thread(syc);
Thread t2 = new Thread(syc);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start(); 
}
@Override
public void run() {
  timer.add(Thread.currentThread().getName());
}
}


class Timer{
public static int num = 0;
public synchronized void add(String name){
try {
Thread.sleep(5);
num ++;
System.out.println(name + "you are " + num + "====");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
  


 
 
示例：死锁/问题没有解决没有成功锁住。
public class Domesychronized1 implements Runnable{
private int flag = 0;
    Object o1 = new Object();
    Object o2 = new Object();
    
public static void main(String[] args) {
Domesychronized1 d1 = new Domesychronized1();
Domesychronized1 d2 = new Domesychronized1();
d1.flag = 0;
d2.flag = 1;
Thread t1 = new Thread(d1);
Thread t2 = new Thread(d2);
t1.start();
t2.start();
}
@Override
public void run() {
System.out.println("flag:" + flag);
 if(flag==0){
 synchronized(o1){
 try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
 synchronized(o2){
 System.out.println("o2");
 }
 }
 }
 
 if(flag==1){
synchronized(o2){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(o1){
System.out.println("o1");
}
}
 }
}
}


示例：一个锁的访问问题：一个方法加锁，另一个不加锁的方法可以访问加锁方法里的数据并修改。
public class Domesynchronized2 implements Runnable{
int b = 100;
public static void main(String[] args) {
      Domesynchronized2 d2 = new Domesynchronized2();
      Thread t = new Thread(d2);
      t.start();
      d2.m2();
}
public synchronized void m1(){
b = 1000;
System.out.println("m1="+b);
}
public void m2(){
b=2000;
System.out.println("m2="+b);
}
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
m1();
}
}


/生产者、消费者问题


注意：wait()/sleep()的异同：
    1.wait()是让当前正在访问该对象的线程休息一会，它是Object类的方法。
      sleep()是让当前线程休息一会。它是Thread类的方法。
    2.wait()方法是休息时不抱着锁的。
      sleep()是休息时仍然会抱着锁的。
    3.wait()方法要靠notify()方法来叫醒。
      sleep()方法是过了特定的时间自动醒。
 notify():叫醒正在正在访问该对象的wait线程。它不能叫醒自己本身。