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("嘿嘿\n");

            System.out.printf("%s线程被调用了\n", Thread.currentThread().getName());

        }

    }

}

class T extends Thread

{

    public void run()

    {

        for (int i=0; i<30; ++i)

        {

            System.out.printf("哈哈\n");

            System.out.printf("%s线程被调用了\n", 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方法时一个线程也没有叫醒，也是可以的。

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

巴特西

java记录5--线程

最新文章

热门文章