Java进程与线程

进程：一个时间允许运行的程序；
单进程，多进程；多进程是同一时间点，允许执行多个程序；轮流对资源进行抢占;
线程：在进程基础上划分的更小的程序单元：依赖于进程;线程启动速度比进程快很多，多线程高并发处理时，速率更高;
Java是多线程编程语言；

多线程实现：线程类，该类必须实现对象接口与继承相应的类，继承了java.lang.Thread的程序类即为线程的主体类;但必须复写Thread的run()主方法;

class Mythread extends Thread//线程主体类
{
    private String title;
    public Mythread(String title)
    {
        this.title=title;
    }

    @Override
    public void run() {
        for(int x=0;x<10;x++)
        {
            System.out.println(this.title+"运行,x="+x);
        }
    }
    //多线程执行的功能应在run()方法中定义;

public class sum {
    public static void main(String[] args) {
        new Mythread("线程A").run();
        new Mythread("线程B").run();
        new Mythread("线程C").run();
    }
}

如果直接使用实例化对象调用run()方法，造成的结果是三个对象顺序执行;因此，实现多线程，必须调用start方法启动多线程;

  public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();//抛出异常;该异常为RuntimeException子类；每个线程类对象只允许启动一次，若重复启动，则抛出异常

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();//只定义了方法，但未实现;关键字为native;

java程序执行过程中，考虑到不同层次开发需求，支持有本地操作系统函数，称为JNI(java native interface)技术；可以使用操作系统提供的底层函数，进行特殊处理；start0（）即为这样的方法;由JVM根据不同的操作系统，控制操作系统底层函数，匹配start0()方法；

由于单继承局限
有第二种多线程主体定义：实现java.lang.Runnable接口，接口定义为：

   class my implements Runnable{//线程主体类，实现Runnable接口
        private String title;
        public my(String title)
        {
            this.title=title;
        }

    @Override
    public void run() {//线程主体方法
        for(int x=0;x<10000;x++)
        {
            System.out.println(this.title+"运行，x="+x);
        }
    }
}
public class sum {
    public static void main(String[] args) {
        //实现多线程操作，必须在Thread类中，使用start方法实现;
        //Thread构造方法中，有Thread(Runnable)方法
        Thread mythread=new Thread(new my("线程A"));
        Thread mythread1=new Thread(new my("线程B"));
        Thread mythread2=new Thread(new my("线程C"));

        mythread.start();
        mythread1.start();
        mythread2.start();
    }
}

Thread与Runnable关系

Thread类实现Runnable接口，之前继承Thread时，覆写的同样是Runnable接口run()；
实现Runnable接口子类的类实现核心业务：
逻辑关系为：
在Thread构造函数中，提供Runnable接口子类初始化Thread类，在Thread中：

public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }//使用init方法初始化Thread类
    
//使用target属性保存Runnable
private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
		this.target = target;
}

//使用target属性启动继承自Runnable的run函数,该run方法为my重新覆写的run方法，而不是Thread的run方法;
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

run（）方法负责处理核心业务（也可以称之为资源）,创建一个实现Runnable接口的类my，覆写run（）方法，实现核心业务；

使用Thread类，创建多个线程对象，共同操作my类，调用my中run()方法，实现对run()资源的抢占；

public class StruggleTicket implements Runnable{
    private int ticket=100;

    private String name;

    StruggleTicket(String name)
    {
        this.name=name;
    }


    @Override
    public void run() {
            for(int i=0;i<1000;i++)
            {
                if(ticket>0){
                    System.out.println(name+"**"+this.ticket--);
                }
            }
    }

    //1000个人抢100张票
    public static void main(String[] args) {
        StruggleTicket exp=new StruggleTicket("station:");//exp表示资源
        new Thread(exp).start();
        new Thread(exp).start();
        new Thread(exp).start();
    }
}

Callable实现多线程
Runnable多线程实现，无法获取返回值。java.util,concurrent.Callable实现多线程。

V call​()
throws Exception

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyThread implements Callable<String>
{
    @Override
    public String call() throws Exception {
        for(int x=0;x<10;x++)
        {
            System.out.println("线程执行"+x);
        }
        return "【线程执行完毕】";
    }
}
public class ThreadDemo {
    public static void main(String[] args) throws Exception{
        FutureTask<String> lis=new FutureTask<>(new MyThread());
        new Thread(lis).start();
        System.out.println("【线程返回数据】"+lis.get());

    }
}

//FutureTask类中，run()方法中调用了callable的call()方法;
    public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }
//Runnable中没有返回值，只有一个run()方法;
//java.util.concurrent.Callable接口中的call方法，有返回值,显示线程运行状态
//但是都依赖于Thread中的start()方法实现多线程;

• 线程对象使用Thread进行封装，线程启动使用的是start()，但启动后，进入就绪状态，没有执行；
• 操作系统调度资源，当线程调度成功后，进去到运行状态run()方法，当线程执行一段时间后，让出资源，进入阻塞状态，随后重新回归到就绪状态；
• run()方法执行完毕后，线程主要任务结束，进入停止状态；