java线程学习

程序 program  一段代码（指令集）  静态

进程  process 操作系统调度程序 为程序运行而分配独立的资源

线程  thread在进程内有多条执行道路   资源共享

一个CPU 通过不断调度  实现虚拟的多个线程同时运行

例如 eclipse运行是
线程组
有 main gc Exception 等线程 互不干扰

package cn.weida.thread.create;
/**
 * 模拟龟兔赛跑
 * 创建多线程  继承 Thread 重写 run（线程体） 方法
 * 创建一个runnable接口实例
 * 使用线程  创建子类对象 调用 start（）方法
 * @author 24569
 *
 */
public class Rabbit extends Thread {
 
 @Override
 public void run() {
  
  for (int i=0;i<1000;i++) {
   System.out.println("兔子跑了"+i);
  }
 }
}

class Tortose extends Thread {
 @Override
 public void run() {
  
  for (int i=0;i<1000;i++) {
   System.out.println("乌龟跑了"+i);
  }
 }
}

package cn.weida.thread.create;

public class RabbitApp {
  //有 main gc exception ra To 五个线程
 public static void main(String[] args) {
  //创建子类对象
  Rabbit ra = new Rabbit();
  Tortose To = new Tortose();
  //调用start（）方法通知CPU 实现调度 直接run()方法  和普通方法没有什么不同 
  ra.start();
  To.start();
  
  for (int i=0;i<1000;i++) {
   System.out.println("main跑了"+i);
  }
 }

}

实现Runnable 静态代理模式
package cn.weida.thread.create;

/**
 * 静态代理模式
 * 1.创建真实角色
 * 2. 创建代理角色 （可以Thread或者自己创建）+真实角色的索引
 * 3.调用start（）方法
 * @author 24569
 *
 */

public class programApp {
 
 
 public static void main(String[] args) {
  //创建真实角色
  program pro = new program();
  //创建代理角色
  Thread proxy = new Thread(pro);
  //启动线程
  proxy.start();
  
  for (int i=0;i<10;i++) {
   System.out.println("一边玩QQ.....");
  }
 }
}

package cn.weida.thread.create;

/**Runnable 实现线程
 * 实现Runnable  接口   重写run() 接口
 * @author 24569
 *
 *1.避免单继承
 *2.资源共享
 */

public class program implements Runnable {

 @Override
 public void run() {
  for (int i=0;i<10;i++) {
   System.out.println("一边写Java.....");
  }
 }
 
}

Callable接口  创建线程  可以申明异常以及获取返回值

new  新生状态
start 就需状态
运行状态
阻塞状态
死亡状态

线程自然停止
外部干干涉
1.线程类中  定义线程体使用标准
2.线程体使用该标识
3.对外提供改变标识方法
4.外部根据实际情况调用方法

阻塞
1. join方法 合并线程 马上获取cpu 别的线程等待该线程结束
2. yieid方法 让出CPU调度 静态方法  写在哪里就那个线程让出
3.  sleep()  静态   休眠  不会释放锁（sleep）
       1.与时间相关
       2.模拟倒计时

thread.currentThread; 当前线程
setName()
getName()
isAlive()
   

优先级 max 10
 norn 5
 min 1
概率大小
 setPriority();

同步  多线程访问同一资源  确保安全

synchronization  同步修饰
同步块
 synchronization {

}
同步方法
 锁定范围大小
synchronization（this）  {
}

单例设计模式 确保一个类只有一个对象  对外部而言

1.构造器私有化  避免外部直接生成对象
2.创建一个对外公布的公共的静态的方法访问变量  如果变量没有对象 创建对象

懒汉式 饿汉式

死锁状态   生产者消费者模式解决 
信号灯法
wati()  等待 释放锁
notfly() 唤醒

package com.bjsxt.thread.pro;
/**
 一个场景,共同的资源
  生产者消费者模式 信号灯法
 wait() :等待，释放锁   sleep 不释放锁
 notify()/notifyAll():唤醒
  与 synchronized
 * @author Administrator
 *
 */
public class Movie {
 private String pic ;
 //信号灯
 //flag -->T 生产生产，消费者等待 ，生产完成后通知消费
 //flag -->F 消费者消费 生产者等待, 消费完成后通知生产
 private boolean flag =true;
 /**
  * 播放
  * @param pic
  */
 public synchronized void play(String pic){
  if(!flag){ //生产者等待
   try {
    this.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  //开始生产
  try {
   Thread.sleep(500);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("生产了:"+pic);
  //生产完毕  
  this.pic =pic;
  //通知消费
  this.notify();
  //生产者停下
  this.flag =false;
 }
 
 public synchronized void watch(){
  if(flag){ //消费者等待
   try {
    this.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  //开始消费
  try {
   Thread.sleep(200);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("消费了"+pic);
  //消费完毕
  //通知生产
  this.notifyAll();
  //消费停止
  this.flag=true;
 }
}

与synchronization连用

任务调度
定时后台启动线程
timer 类

package com.bjsxt.thread.schedule;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
/**
    了解
  Timer()
  schedule(TimerTask task, Date time)
  schedule(TimerTask task, Date firstTime, long period)
  自学 quartz
 * @author Administrator
 *
 */
public class TimeDemo01 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  Timer timer =new Timer();
  timer.schedule(new TimerTask(){

   @Override
   public void run() {
    System.out.println("so easy....");
   }}, new Date(System.currentTimeMillis()+1000), 200);
 }

}