javaoop_多线程

2018/03/13 15:41
阅读数 32

在java 虚拟机进程中,执行程序代码的任务是由线程来完成的,每个线程都有一个独立的程序计算器和方法调用栈(method invocation stack)

每当用java命令启动一个Java虚拟机进程是,Java虚拟机都会创建一个主程序,该程序从程序入口main()方法开始执行。

进程:应用程序的执行实例,有独立的内存空间和系统资源,

线程:cpu调度和分派的基本单位,进程中执行运算的最小单位,可完成一个独立的顺序控制流程

多线程:如果在一个进程中同时运行了多个线程,用来完成不同的工作,多个线程交替占用cpu资源,而非真正的执行

多线程的好处:
1.充分利用cpu的资源
2.简化编程模型
3.带来良好的用户体验

用户还可以创建自己的线程,它将和主线程并发运行,创建有两种方式:

 继承Thread类
1.编写简单,可直接操作线程
2.适用于单继承
实现Runnable接口
1.避免单继承局限性
2.便于共享资源

Thread类

java提供了Java.lang.Thread类支持多线程编程
主线程
main()方法即为主线程入口
产生其他子线程的线程
必须最后完成执行,
因为它执行各种关闭动作

run()方法:包含线程运行时执行的代码

start()方法:用于启动线程

用户的线程类只需要继承Thread类 覆盖Thread类的run()方法即可

 线程字段:
MNX_PRIORITY:          线程可以具有最高优先级
MIN_PRIORITY:              线程可以具有的最低优先级
NORM_PRIORITY:       分配给线程的默认优先级
void join():                     等待线程终止。
void run() :            如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。
 void setName(String name) :   改变线程名称,使之与参数 name 相同。
 void setPriority(int newPriority) : 更改线程的优先级。  
static void sleep(long millis) :   在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。
 void start() :          使该线程开始执行;Java 虚拟机调用该线程的 run 方法。
static void yield() :        暂停当前正在执行的线程对象,并执行其他线程。
Boolean isAlive():        测试线程是否处于活动状态
void interrrupt():        中断线程

线程对象调用start()方法和调用run()方法的区别
run():            只有主线程一条执行路径
start():           多条执行路径,主线程和子线程并行交替执行

---继承Thread类创建线程

示例--

public class Hello extends Thread{
    
    public void run() 
    {
        for(int i=0;i<10;i++) 
        {
            System.out.println(i+"."+"你好,来自线程"+Thread.currentThread().getName());
        }
    }
}
public class MyThread {

    public static void main(String[] args) {
        
        Hello thread1=new Hello();        
        thread1.start();
        Hello thread2=new Hello();
        thread2.start();
    }

}

--实现Runnable接口创建线程

示例---

public class Hello implements Runnable{

    @Override
    public void run() {
        
        for(int i=0;i<10;i++) 
        {
            System.out.println(i+"."+"你好,来自线程"+Thread.currentThread().getName());
        }
    }
public class MyRunnable {

    public static void main(String[] args) {
        
        Hello hello=new Hello();
        Thread thread1=new Thread(hello);
        thread1.start();
        Thread thread2=new Thread(hello);
        thread2.start();
    }

}

----线程的运行状态

--线程的休眠

示例--

public class ThreadDemo {
    
    public void bySec(long s) {
        for (int i = 1; i <=s; i++) {
            System.out.println(i+"秒");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                
                e.printStackTrace();
            }
        }
    }
}
public class Wait {

    public static void main(String[] args) {
        ThreadDemo t=new ThreadDemo();
        System.out.println("Wait");
        t.bySec(5);
        System.out.println("start");
    }

}

---线程的强制运行

示例--

public class MyThread implements Runnable{

    @Override
    public void run() {
        for(int i=1;i<=10;i++) 
        {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"运行"+i);
        }
    }

}
public class ThreadJoinDemo {

    public static void main(String[] args) {
        System.out.println("线程强制执行");
        
        Thread t=new Thread(new MyThread());
        t.start();
        for(int i=1;i<=10;i++) {
            if(i==5) {
                try {
                    t.join();
                } catch (InterruptedException e) {
                    
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    
                    e.printStackTrace();
                }
                
            }
            System.out.println(Thread.currentThread().getName()+"运行"+i);
        }
    }

}

--线程的礼让

示例--

public class MyThread implements Runnable{

    @Override
    public void run() {
        for(int i=1;i<=5;i++) {
            System.out.println(Thread.currentThread().getName()+"正在运行"+i);
            if(i==3) {
                System.out.println("线程礼让");
                Thread.yield();
            }
        }
    }

}
public class ThreadYieldDemo {

    public static void main(String[] args) {
        
        Thread t1=new Thread(new MyThread(),"线程A");
        Thread t2=new Thread(new MyThread(),"线程B");
        t1.start();
        t2.start();
    }

}

线程的同步实现

示例--

public class Printer {

    public synchronized void printer1() 
    {
        System.out.print("j");
        System.out.print("a");
        System.out.print("v");
        System.out.println("a");
    }
    
    public synchronized void printer2() 
    {
        System.out.print("编");
        System.out.println("程");
    }
}
public class MyThread1 implements Runnable{

    public Printer printer;
    
    @Override
    public void run() {
        for(int i=1;i<=20;i++)
        {
            printer.printer1();
        }
        
    }

}
public class MyThread2 implements Runnable{

    public Printer printer;
    
    @Override
    public void run() {
                
            for(int i=1;i<=20;i++)
            {
                printer.printer2();
            }
    }

}
public class MyMain {

    public static void main(String[] args) {
        MyThread1 m1=new MyThread1();
        Thread t1=new Thread(m1);
        
        MyThread2 m2=new MyThread2();
        Thread t2=new Thread(m2);
        
        Printer printer=new Printer();
        m1.printer=printer;
        m2.printer=printer;
        t1.start();
        t2.start();
        
    }

}

通过在方法声明中加入synchronized关键词来声明同步方法

访问修饰符 synchronized 返回类型 方法名 (参数类型){//方法体}

或者

synchronized 访问修饰符 返回类型  方法名 (参数类型){//方法体}

 

展开阅读全文
加载中

作者的其它热门文章

打赏
0
0 收藏
分享
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部
返回顶部
顶部