• 大四实习准备3_java多线程


    4.25、27无耻地懒散了。。。。。26号陪女朋友去了。今天28号,继续加油!

    2015-4-28

    Java 多线程

    (java中类不能多继承,可以多层继承;接口则都可以)

    定义和创建

    方法一:继承Thread类

    方法二:实现Runnable接口(以匿名内部类的方式来实现也行)

    启动线程

    线程只能被启动一次,多次启动线程,即多次调用start方法时,会发生IllegalThreadStateException异常;

    //以上综合来个code

     1 class xianCheng1 extends Thread{
     2     public void run(){
     3         for(int i=0;i<1000;i++)
     4             System.out.println("通过继承Thread定义线程");
     5     }
     6 }
     7 
     8 class xianCheng2 implements Runnable{
     9     public void run(){
    10         for(int i=0;i<1000;i++)
    11             System.out.println("通过实现Runnable接口定义线程");
    12     }
    13 }
    14 
    15 public class test{
    16     public static void main(String[] args){
    17         xianCheng1 xc1 = new xianCheng1();//通过继承Thread创建线程对象是比较简单的
    18         
    19         xianCheng2 _xc2 = new xianCheng2();
    20         Thread xc2 = new Thread(_xc2);//通过实现Runnable接口创建线程对象就稍微复杂了下
    21         
    22         xc1.start();
    23         xc2.start();//是用start()方法,而不是直接调用run()方法,否则就当是普通的函数调用。
    24         
    25         new Thread(new Runnable(){
    26 
    27             @Override
    28             public void run() {
    29                 for(int i=0;i<1000;i++)
    30                     System.out.println("通过匿名内部类的方式实现Runnable接口来定义线程");
    31             }
    32             
    33         }).start();//或者直接通过匿名内部类的方式实现Runnable接口来定义线程
    34     }
    35 }
    例1

    线程的生命周期:

    线程调度:

     

    (join()方法的状态变化?另外,stop()方法应当也是从运行态变成死亡态)

    1.睡眠方法

    运行态,调用sleep(time)方法后,进入阻塞态。然后经过time时间后,进入准备态,等待系统调度。再经过一个随机(?应当是的)的时间,重新进入运行态。(从阻塞态到运行态:经过总时间是time+随机)

    //函数声明

    public static void sleep(long millis)throws InterruptedException;

    public static void sleep(long millis,int nanos)throws InterruptedException;

    //code必须进行异常处理,否则运行时会发生异常"未报告的异常..."  静态方法,与对象无关

    可以通过sleep()方法,实现两个线程交替执行。

     1 class xianCheng1 extends Thread{
     2     public void run(){
     3         for(int i=0;i<10;i++){
     4             System.out.println("通过继承Thread定义线程");
     5             //新增部分:
     6             try{
     7                 Thread.sleep(100);
     8             }catch(InterruptedException e){
     9                 e.printStackTrace();
    10             }
    11         }
    12     }
    13 }
    14 
    15 class xianCheng2 implements Runnable{
    16     public void run(){
    17         for(int i=0;i<10;i++){
    18             System.out.println("通过实现Runnable接口定义线程");
    19             //新增部分:
    20             try{
    21                 Thread.sleep(100);
    22             }catch(InterruptedException e){
    23                 e.printStackTrace();
    24             }
    25         }
    26     }
    27 }
    28 
    29 public class test{
    30     public static void main(String[] args){
    31         xianCheng1 xc1 = new xianCheng1();//通过继承Thread创建线程对象是比较简单的
    32         
    33         xianCheng2 _xc2 = new xianCheng2();
    34         Thread xc2 = new Thread(_xc2);//通过实现Runnable接口创建线程对象就稍微复杂了下
    35         
    36         xc1.start();
    37         xc2.start();//是用start()方法,而不是直接调用run()方法,否则就当是普通的函数调用。
    38     }
    39 }
    例2

    2.线程优先级

    从1到10,数字越大、优先级越高。默认的优先级为5。子线程的优先级与父线程相同。

    Thread类中有3个表示优先级的常量,MAX_PRIORITY,NORM_PRIORITY,MIN_PRIORITY。

    public final void setPriority(int i);

    3.让步方法

    3.1 yield让步方法 使线程让出当前cpu,进入准备状态,而之后执行哪个线程是不确定的,有系统来选择,有可能还是这个线程。

    可以通过yield()方法,实现两个线程交替执行。

    public static void yield();

    //code 静态方法,与对象无关

     1 class xianCheng1 extends Thread{
     2     public void run(){
     3         for(int i=0;i<100;i++){
     4             System.out.println("通过继承Thread定义线程");
     5             //改变部分:
     6             Thread.yield();
     7         }
     8     }
     9 }
    10 
    11 class xianCheng2 implements Runnable{
    12     public void run(){
    13         for(int i=0;i<100;i++){
    14             System.out.println("通过实现Runnable接口定义线程");
    15             //改变部分:
    16             Thread.yield();
    17         }
    18     }
    19 }
    20 
    21 public class test{
    22     public static void main(String[] args){
    23         xianCheng1 xc1 = new xianCheng1();//通过继承Thread创建线程对象是比较简单的
    24         
    25         xianCheng2 _xc2 = new xianCheng2();
    26         Thread xc2 = new Thread(_xc2);//通过实现Runnable接口创建线程对象就稍微复杂了下
    27         
    28         xc1.start();
    29         xc2.start();//是用start()方法,而不是直接调用run()方法,否则就当是普通的函数调用。
    30     }
    31 }
    例3

    3.2 join让步方法 将当前线程的cpu资源让步给指定的线程

    //函数声明,及有参数函数的意义?(?认为是执行这么长的时间,然后该线程退出cpu,开始和别的线程并发)

    public final void join()throws InterruptedException;

    public final void join(long millis)throws InterruptedException;

    public final void join(long millis,int nanos)throws InterruptedException;

    //code 必须进行异常处理

     1 class xianCheng1 extends Thread{
     2     public void run(){
     3         for(int i=0;i<1000;i++)
     4             System.out.println("通过继承Thread定义线程");
     5     }
     6 }
     7 
     8 public class test{
     9     public static void main(String[] args){
    10         xianCheng1 xc1 = new xianCheng1();
    11                 
    12         xc1.start();
    13         try{
    14             xc1.join();
    15             //xc1.join(1);
    16         }catch(InterruptedException e){
    17             e.printStackTrace();
    18         }
    19         System.out.println("The End");
    20     }
    21 }
    例4
  • 相关阅读:
    mybatis连接MySQL8.0出现的问题
    zqsb项目中发现没有getMSSVideoList
    idea快速实现接口的方法
    鸟枪换炮---IDEA
    IDEA的使用---常用的快捷键
    MQ消息队列
    token的主要用法?
    oracle中游标的使用
    乐观锁和悲观锁
    分布式系统的事务控制
  • 原文地址:https://www.cnblogs.com/kiwi-bird/p/4462591.html
Copyright © 2020-2023  润新知