Java进程与多线程

一：进程与线程的区别：

1.线程：程序中单独顺序的控制流，线程本身依靠程序进行运行，线程   是程序中的顺序控制流，只能使用分配给程序的资源和环境。

2.进程：执行中的程序一个程序可以包含一个或多个线程一个进程自少     要包含一个线程。

3.单线程：程序中只存在一个线程，实际上主方法就是一个主线程。

多线程：多线程是在一个程序中运行多个任务，多线程的目的是更           好的使用CPU资源。

 

二：线程的实现：

1.在Java中，线程的实现有2种：

    <1>继承Thread类

     <2>实现Runnable接口

2.Thread 类：

    Thread类是在Java.lang包中定义的，继承Thread类必须重写run()方法

    定义的格式：

    class 类名 extends Thread{

        run(){};

    }

3.Runnable接口

 

一 二代码实例在最后。

 

三：线程的状态

1.线程也有固定的操作状态

    创建状态：准备好了一个多线程的对象

    就绪状态：调用了strat（）方法，等待cpu进行调度

    运行状态：执行run（）方法

    阻塞状态：暂时停止执行，可能将资源交给其他线程使用

    终止状态（死亡状态）：线程销毁

 

四：线程的常用方法

1.取得线程名字

    getName()

2.取得当前线程对象

    currentThread()

3.判断线程是否启动

    isAlive()

4.线程的强行运行

    join()

5.线程的休眠

    sleep()

 

 

五：线程的优先级别

    1-MIN_PRIORITY

    10-MAX_PRIORITY

    5-NORM_PRIORITY

    如果什么都不设置默认值是5

 

六：同步与死锁

什么时候需要使用同步：在资源共享的时候需要

1.同步代码块

    在代码块上加"synchronized"关键字，则此代码块就称为同步代码块。

2.同步代码块格式：

    synchronized(同步对象)｛

            需要同步的代码块；

｝

3.同步方法：

    除了代码块可以同步，方法也是可以同步的

4.方法同步格式：

    synchronized void 方法名称(){}

 

5.死锁：所谓死锁： 是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

比如：大学生找工作要找高薪的而企业要有经验才给高薪，如果双方标准都不降低就无法继续。

 

七：线程的生命周期

 

 

一和二代码：
代码一run方法：
package Java线程;
public class MyThread extends Thread {
    private String name;
    //创建构造方法进行传参
    public MyThread(String name){
        this.name=name;
    }
    //重写Run方法
    public void run(){
        //为了能看到用for循环做打印
        for(int i=0;i<1000;i++){
            System.out.println(name+":"+i);
        }
        //super.run();
    }
}
代码一run方法：
package Java线程;
//调用线程的主方法
public class ThreadDemo{
    public static void main(String [] args){
        //实例化线程A B启动线程
        MyThread t1=new MyThread("线程A：");
        MyThread t2=new MyThread("线程B：");
        //线程的启动是通过start（）方法启动的
        t1.start();
        t2.start();


    }
}


代码二：Runnable接口
package 线程2;


//第二种方法通过实现Runnable接口来实现线程
public class MyRunnable implements Runnable{
    private String name;


    //构造方法传递参数标识当前线程
    public MyRunnable(String name){
        this.name=name;
    }


    //Runnable接口也要重写run方法
    public void run() {
        for(int i=0;i<1000;i++){
            System.out.println(name+":"+i);


        }


    }


}
代码二：runnable接口
package 线程2;


public class ThreadDemo2 {


    public static void main(String[] args) {
        //实现MyRunnable
        MyRunnable r1=new MyRunnable("线程A：");//A是一个name 标识当前的线程
        MyRunnable r2=new MyRunnable("线程B：");
        //runnable 接口不存在启动方法要通过线程启动
        Thread t1=new Thread(r1);//r1 r2为传递进来的Runnable 对象
        Thread t2=new Thread(r2);
        t1.start();
        t2.start();
    }


}


代码三同步与死锁：
package Java线程;


//线程的同步与死锁


class MyThreadDemo implements Runnable{


    private int ticket=5;
    public void run() {
        for(int i=0;i<10;i++){


            //调用tell方法
            tell();
            //为了资源能够共享使用线程同步（第一种方法）
            /*synchronized (this) {
                if(ticket>0){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("车票："+ticket--);
                */
                }


            }
            //第二种使用线程同步方法来实现线程同步实现资源共享
            public  synchronized void tell(){
                if(ticket>0){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("车票："+ticket--);
        }
    }


}




public class ThreadDemo05 {
    //主方法
    public static void main(String[] args) {
        MyThreadDemo m=new MyThreadDemo();
        Thread t1=new Thread(m);
        Thread t2=new Thread(m);
        Thread t3=new Thread(m);
        t1.start();
        t2.start();
        t3.start();
    }


}