java记录5--线程

------------恢复内容开始------------

1.什么叫程序：是一个严格有序的指令集合。程序规定了完成某一任务时，计算机所需做的各种操作，已经执行顺序。

特点：资源的独占性     执行的顺序性      结果的再现性

ps；多道程序：存在多个用户程序，这些程序同时运行

特点：间断性：由于资源共享和合作，并发程序间互相制约，造成合作执行间断

失去封闭性：程序执行可以受外界影响

不可再现性：重复执行时，可能得到不同结果

2.进程的由来：为了不破坏“程序”这个词原来的含义，而又能刻画多个程序共同运行时呈现出的新特征，所以引入了进程这一概念

进程：程序只是一组指令的有序集合，而进程是程序在某个数据集上的执行。进程是一个动态的实体，有自己的生命周期。

因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤销。

3。线程：一个程序里不同的执行路径

以前所编写的程序，只有一个入口，出口，只有一个单独的执行点。

事实上，单个程序内部是可以在同一时刻进行多种运算，这就是所谓的多线程

4.如何创建一个线程

4.1创建一个继承Thread的类，假设类名为A，并重写Thread中的run方法

4.2构造一个A类对象，假设对象名为aa；

4.3调用aa的start方法（从thread继承而来）

public class A
{
    public static void main(String[] args)
    {
        B aa = new B();
        aa.start();
        while(true)
     {
     System.out.println("aaaa");
     }
    }
}
class B extends Thread
{
    public void run()
    {
        while(true)
        {
        System.out.println("AAAA");
      }
    }
}

ps：1.thread中的start（）方法的功能就是创建一个新的线程，并自动调用该线程的run（）方法，直接调用run（）方法是

不会创建一个新的线程的

2.执行一个线程实际就是执行该线程run方法中的代码

3.执行完aa。start（）后并不代表aa所代表的线程一定会被执行，只是代表该线程具有了可以被cpu执行的资格，但由于想抢占cpu的线程很多，cpu并不一定会立即去执行aa所对应的线程

4.一个thread对象能且只能代表一个线程，不能调用两次start（）方法；否则会抛出

java.lang.IIIegalThreadStartException异常

创建一个新线程的第二种方法

1.定义一个实现了Runnable接口的类，假设为A

2.创建A类对象aa;    A aa = new A（）；

3.利用aa构造一个Thread对象tt

Thread tt = new Thread(aa);

4.调用tt中的start方法     tt.start（）；

thread的常用方法

1Thread.Name（String name）

设置当前线程的名字

2.Thread.currentThread（）

返回对当前正在执行线程对象的引用

3.Thread。getName（）

返回当前线程的名字

public class A
{
    public static void main(String[] args)
    {
        T t = new T();
        t.setName("呀哈哈");  //不能写成setName("呀哈哈");
        t.start();
        
        
        for (int i=0; i<30; ++i)
        {
            System.out.printf("嘿嘿
");
            System.out.printf("%s线程被调用了
", Thread.currentThread().getName());
        }
    }
}

class T extends Thread
{
    public void run()
    {

        for (int i=0; i<30; ++i)
        {
            System.out.printf("哈哈
");
            System.out.printf("%s线程被调用了
", Thread.currentThread().getName());
        }
    }
        
}

线程的控制

 1.isAlive（）   判断线程是否还存在，即线程是否还未终止

2.setPriority（）设置线程的优先级数值  //线程的优先级用数字表示，范围从1到10逐渐升高

3.getPriority（）获得线程的优先级数值  //住线程优先级是5，子线程优先级默认与父线程相同

4.Thread.sleep（）为当前线程睡眠设定毫秒数

5.join（） 调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行

6.yield（） 让出cpu，当前线程进入就绪等待调度

7.wait（） 当前线程进入对象的wait pool

8.notify（）/notyfyAll（）  唤醒对象的wait pool 中的一个/所有等待线程

 线程的休眠：暂停执行当前运行中的线程，使之进入阻塞状态，经过指定的时间再醒来转入就绪状态。

public static void sleep（long millis）  静态方法，可由thread直接调用

sleep（）方法会抛出interrupted Exception异常，必须得对其进行捕获

public class TestSleep{
    public static void main(String[] args){
        A aa = new A();
        Thread tt = new Thread(aa);
        tt.start();        
    }
}
class A implements Runnable{
    public void run(){
          for (int i=0; i<10; ++i){
        System.out.println(Thread.currentThread().getName() + "   " + i);
        try{
              Thread.sleep(1000); //这里的Thread.sleep(1000)会抛出异常,必须
                                  //的进行捕捉，不能在run的后面添加 throws Exception
        }catch (Exception e){  }
         }
    }
}//原因：重写方法抛出异常的范围不能大于被重写方法排除的异常范围

 线程的让步：让运行中的线程主动放弃当前获得的cpu处理机会，并不是使该线程阻塞，而是让其转入就绪状态

public class TestYield
{
    public static void main(String[] args) 
    {
       MyThread mt = new MyThread();
       Thread t1 = new Thread(mt);
       Thread t2 = new Thread(mt);
       
       t1.setName("线程A");
       t2.setName("线程B");
       
       t1.start();
       t2.start();
    }
}
class MyThread implements Runnable 
{
    public void run()
    {
        for(int i=1;i<=100;i++)
        {
            System.out.println(Thread.currentThread().getName()+": "+i);
              if(0 == i%10)
              {
                Thread.yield();
              }
        }
      }
}

 线程的串行化：在多线程程序中，如果一个线程运行的过程中要用到另一个线程的运行结果，则可进行线程的串行化处理；public final void join（）

public class TestJoin {    
    public static void main(String args[]){
        MyRunner r = new MyRunner();
        Thread t = new Thread(r);
        t.start();
        try{
            t.join(); //7行  暂停当前正在执行t.join();的线程，直到t所对应的线程运行终止之后，
当前线程才会获得继续执行的机会
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        for(int i=0;i<50;i++){
            System.out.println("主线程:" + i);
        }
    }ps：t.join（）不是暂停t对象所对应的线程
}

class MyRunner implements Runnable {
    public void run() {
        for(int i=0;i<50;i++) {
            System.out.println("子线程: " + i);
        }
    }
}

 关键词 Synchronized  （同步）  用来修饰一个方法或一个方法内部的某个代码块

 格式   synchronized（类对象名a）{  同步代码块  }

 意义：判断a是否已经被其他线程霸占（锁定），如果发现已经被其他线程霸占，则当前线程陷入等待，如果a没有被其他线程霸占，则当前线程霸占a对象，并执行同步代码块，在当前线程执行同步代码时，其他线程将无法再执行，当前线程执行完3行代码后，会自动释放对a对象的霸占，此时其他线程会相互竞争对a的霸占，最终cpu会选择某一个线程执行。

结果：一个线程正在操作某资源的时候，将不允许其他线程操作该资源，即一次只允许一个线程处理该资源。

修饰方法时，实际锁定的是该方法的this指针所指向的对象，锁定正在调用该方法的对象（监听器）

notify和wait方法补充

1.不是叫醒正在执行this。notify（）的当前线程，而是叫醒一个正在wait    this对象的其他线程，如果有多个对象正在等待，通常是叫醒最先等待的线程，但具体叫醒哪一个，由系统调度器控制，程序员无法操控。同时，如果执行notify方法时一个线程也没有叫醒，也是可以的。

------------恢复内容结束------------