精华内容
下载资源
问答
  • 启动线程的三种方式

    千次阅读 2021-01-01 07:41:29
    文章目录前言一、启动线程的第一种方法:继承类二、启动线程的第二种方式:实现接口三、启动线程的第三种方式:匿名内部类 前言 启动线程一共有三种方法:继承类,实现接口,匿名内部类。 一、启动线程的第一种...


    前言

    启动线程一共有三种方法:继承类,实现接口,匿名内部类。


    一、启动线程的第一种方法:继承Thread类

    start()方法的作用是启动一个分支线程,在JVM中开辟一个新的栈空间。
    只要新的栈空间,myThread.start()瞬间就结束了,线程就启动成功了。
    启动成功的线程会自动调用run方法,并且run方法在分支线的栈底部。

    代码如下(示例):

    public class Thread01  {
        public static void main(String[] args) {
            //创建线程对象
            MyThread myThread = new MyThread();
            //启动线程
            myThread.start();
    
            //主线程
            for (int i = 0; i <100 ; i++) {
                System.out.println("main主线程--->" + i);
            }
    
        }
    }
    class MyThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i <100 ; i++) {
                System.out.println("分支线程---->"+ i);
            }
        }
    }
    

    二、启动线程的第二种方式:实现Runnable接口

    代码如下(示例):

    public class Thread02 {
        public static void main(String[] args) {
            //创建线程对象
            Thread thread = new Thread(new MyRunnable());
            //启动线程
            thread.start();
    
            //主线程
            for (int i = 0; i <100 ; i++) {
                System.out.println("main主线程--->" + i);
            }
        }
    }
    class MyRunnable implements Runnable{
    
        @Override
        public void run() {
            for (int i = 0; i <100 ; i++) {
                System.out.println("分支线程---->"+ i);
            }
        }
    }
    

    实现接口启动线程是最常用的方法


    也可以使用匿名内部类的方式启动线程

    代码如下(示例):

    public class Thread03 {
        public static void main(String[] args) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i <1000 ; i++) {
                        System.out.println("分支线程-->" + i);
                    }
                }
            });
    
            //启动线程
            thread.start();
    
            //主线程
            for (int i = 0; i <1000 ; i++) {
                System.out.println("main主线程--->"+ i);
            }
        }
    }
    

    三、启动线程的第三种方式:实现Callable接口

    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /***
     * 启动线程的第三种方法:实现Callable接口,重写call()方法
     */
    public class ThreadTest04 {
        public static void main(String[] args) {
            //创建一个“未来任务类”对象
            FutureTask futureTask = new FutureTask(new Callable() {
                @Override
                public Object call() throws Exception { //call()方法相当与run()方法,比run方法好,有返回值
                    System.out.println("call mothed begin!");
                    Thread.sleep(1000 * 10);
                    System.out.println("call mothed over!");
    
                    int x = 100;
                    int y = 200;
    
                    return x + y;//自动装箱
                }
            });
    
            //创建线程对象
            Thread t = new Thread(futureTask);
    
            //启动线程
            t.start();
    
            Object obj = null;
            //获得分支线程返回值
            try {
                //get()方法的执行会导致主线程的阻塞
                obj = futureTask.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
            System.out.println("获得分支线程的返回值:" + obj );
    
            //如下的代码会等到分支线程执行结束后,才回到主线程中继续执行
            System.out.println("Hello CSDN");
        }
    }
    
    
    展开全文
  • 易语言自动启动线程命令(),其实就是对API CreateThread的封装,我们如何启动线程的时候让它传递多个参数,并且类型可以是整数,是文本,在前面几个文章里,讲解了启动线程传参文本型,多个参数等等,今天我们用...

    易语言自动启动线程命令(),其实就是对API CreateThread的封装,我们如何启动线程的时候让它传递多个参数,并且类型可以是整数,是文本,在前面几个文章里,讲解了启动线程传参文本型,多个参数等等,今天我们用自定义数据结构类型的方式来实现,使用lstrcat该函数将字符串lpString2附加在另一个字符串lpString1后面从而实现多参数的传递。可以先参考以下两篇文章了解多线程的传参。

    易语言启动线程传递文本参数
    易语言启动线程传递多个类型变量

    自定义传递的参数结构

    这里我们只定义了文本和整数,你要传递其他的,可以再定义几个,或者多个。

    511遇见(www.511yj.com) 

    .版本 2
     
    .数据类型 参数结构
        .成员 整数, 整数型
        .成员 文本, 文本型

    封装 API_启动线程

    第二参数是我们传递的参数,这里先定义成整数

    511遇见(www.511yj.com) 

    .版本 2
    .子程序 API_启动线程, 整数型
    .参数 子程序指针, 子程序指针
    .参数 整数参数, 整数型, 可空
    .局部变量 hThread, 整数型
    
    hThread = CreateThread (0, 0, 子程序指针, 整数参数, 0, 0)  ' 返回线程句柄
    CloseHandle (hThread)  ' 关闭线程句柄
    返回 (hThread)

    多参传递调用示范

    先定义一个变量:参数结构,它的类型就是我们自定义的数据结构类型,
    通过lstrcatA (参数结构, 0)进行参数传递。

    511遇见(www.511yj.com) 

    .版本 2
     
    .局部变量 参数结构, 参数结构, 静态
     
    参数结构.整数 = 20200606
    参数结构.文本 = “文本型内容”
    API_启动线程 (&线程主线程, lstrcatA (参数结构, 0))

    线程主线程

    在启动的线程主线程里,我们采用了RtlMoveMemory (参数结构, 参数, 4 × 2) ' 复制内存 结构数据,把传递进来的参数给接受过来。

    511遇见(www.511yj.com) 

    .版本 2
    
    .子程序 线程主线程
    .参数 参数, 整数型
    .局部变量 参数结构, 参数结构
    
    RtlMoveMemory (参数结构, 参数, 4 × 2)  ' 复制内存 结构数据
    输出调试文本 (参数结构.文本, 参数结构.整数)

    用到的API

    511遇见(www.511yj.com) 

    .版本 2
     
    .DLL命令 RtlMoveMemory
        .参数 Destination, 参数结构, 传址
        .参数 Source, 整数型
        .参数 Length, 整数型
     
    .DLL命令 lstrcatA, 整数型, , "lstrcatA"
        .参数 lpString1, 参数结构, 传址, 此参数结构可以自定义
        .参数 lpString2, 整数型, 传址
     
    .DLL命令 CreateThread, 整数型
        .参数 lpThreadAttributes, 整数型
        .参数 dwStackSize, 整数型
        .参数 lpStartAddress, 子程序指针
        .参数 lpParameter, 整数型
        .参数 dwCreationFlags, 整数型
        .参数 LpthreadId, 整数型, 传址
     
    .DLL命令 CloseHandle, 逻辑型
        .参数 hObject, 整数型

    源码:易语言CreateThread启动线程传递多个类型参数

    展开全文
  • 启动线程的五种方式

    万次阅读 2017-08-15 22:47:00
    启动线程的五种方式(通过继承Thread类或实现Runnable接口) package codes; /** * 启动线程的五种方式方法: * 本质:继承Thread类或实现runnable接口 */ public class ThreadStartDemo { public static ...

    启动线程的五种方式(通过继承Thread类或实现Runnable接口)

    package codes;
    
    /**
     * 启动线程的五种方式方法:
     * 本质:继承Thread类或实现runnable接口
     */
    public class ThreadStartDemo {
    	 
    	 public static void main(String[] args) {
    		 
    		  //1.使用匿名内部类创建线程
    		  Thread t1 = new Thread(){
    			   public void run(){
    				   System.out.println("匿名内部类创建线程成功");
    			   }
    		  };
    		  t1.start();
    		  
    		  
    		  //2.使用runnable接口创建线程
    		  Runnable r = new Runnable(){
    			   public void run(){
    				   System.out.println("runnable接口创建线程成功");
    			   }
    		  };
    		  Thread t2 = new Thread(r);
    		  t2.start();
    		  
    		  
    		  //3.使用runnable接口创建创建匿名类,创建线程实例
    		  Thread t3 = new Thread(new Runnable(){
    			   public void run() {
    				   System.out.println("使用runnable接口创建创建匿名类,创建线程实例成功");
    			   }
    		  });
    		  t3.start();
    		  
    		  
    		  //4.创建匿名类实例,直接启动线程
    		  new Thread(){
    			   public void run(){
    				   System.out.println("创建匿名类实例,直接启动线程成功");
    			   }
    		  }.start();
    		  
    		  
    		  //5.创建匿名类实例,实现runnable接口,直接启动线程
    		  new Thread(new Runnable(){
    			   public void run(){
    				   System.out.println("创建匿名类实例,实现runnable接口,直接启动线程");
    			   }
    		  }).start();
    	 }
    }
    




    展开全文
  • Thread 和 启动线程几种方式

    千次阅读 2019-02-15 10:20:09
    启动线程几种方式第一种: 1】d定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。 2】创建Thread子类的实例,也就是创建了线程对象 3】启动线程,...

    1.继承 Thread类(重写 run())

    2.实现 Runnable接口(重写 run())

    3.实现 Callable接口(重写 call())

    启动线程几种方式第一种:
    1、定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。
    2、创建Thread子类的实例,也就是创建了线程对象
    3、启动线程,即调用线程的start()方法 注:start ()是真正的启用了线程 run() 只是thread类的一个方法
    在这里插入图片描述

    第二种:
    A类实现runnable 重写run 方法
    B类中创建A类的对象
    但是要使用Thread 去把对象当做参数一个启动线程

    方式一:
    在这里插入图片描述
    单独类的写法

    Thread thread = new Thread(){
        @Override
        public void run() {
            System.out.println(123);
         }
    };
    thread.start();
    

    方式二:
    在这里插入图片描述

    第三种:
    实现Callable接口创建线程与Runnable接口的不同之处在于:如果你想要在线程执行完毕之后得到带有返回值的线程则实现Callable接口。
    在这里插入图片描述
    在这里插入图片描述
    特征:
    1.线程有 6 种状态。
    2 每个线程都有一个优先级,高优先级线程的执行优先于低优先级线程。 设
    置的优先级不会高于线程组的最大优先级。
    3.每个线程都可以设置成一个守护线程(只能在启动之前设置,不能再启动
    之后设置)。
    4.当新建一个 Thread 时,该线程的初始优先级被设定为创建线程的优先级,
    如果创建线程是守护线程, 那么新线程也是守护线程。
    线程状态:
    NEW: 初始状态,线程被创建, 但是还没有调用 start()。
    RUNNABLE: 运行状态。 Java 线程将操作系统中的就绪和运行两种状态笼统
    地称作“运行中”。
    BLOCKED: 阻塞状态,等待持有锁。
    WAITING:等待状态, 进入该状态表示当前线程需要等待其他线程做出一些
    特定的动作(通知或中断)。
    TIMED_WAITING: 超时等待状态。
    TERMINATED:终止状态。
    方法:
    start():线程启动方法。
    join():堵塞主线程,使其处于等待状态,直到子线程死掉。
    sleep():睡眠指定毫秒, 并不释放 monitor。
    yeild():使当前线程从运行状态变为就绪状态。 cpu 会从众多的可执行态里
    选择,也就是说,当前也就是刚刚的那个线程还是有可能会被再次执行到的,并
    不是说一定会执行其他线程而该线程在下一次中不会执行到了。
    suspend(): 将一个线程挂起(暂停), 过时。 它不会释放锁。
    resume(): 将一个挂起线程复活继续执行, 过时。
    interrupt(): 中断线程。 线程的状态被设置为“中断”状态。 线程中断仅仅是设
    置线程的中断状态位,不会停止线程。
    interrupted():清除中断状态,会重置中断状态位为 true。作用于当前线程。
    isInterrupted():静态方法,返回当前线程的中断状态,不会重置中断状态位。
    作用于调用该方法的线程对象所对应的线程。
    holdsLock(obj):判断当前线程是否拥有对象的监视器。
    注意:
    1.wait()方法会释放 CPU 执行权和占有的锁。
    2.sleep(long)方法仅释放 CPU 使用权,锁仍然占用;线程被放入超时等待队
    列,与 yield 相比,它会使线程较长时

    thread jdk 源码
    public class Thread

    implements Runnable {
    private static native void registerNatives();
    static {
    registerNatives();
    }

    private volatile String name;
    private int            priority;
    private Thread         threadQ;
    private long           eetop;
    
    private boolean     single_step;
    
    private boolean     daemon = false;
    
    private boolean     stillborn = false;
    
    private Runnable target;
    
    private ThreadGroup group;
    
    private ClassLoader contextClassLoader;
    
    private AccessControlContext inheritedAccessControlContext;
    
    private static int threadInitNumber;
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }
    
    ThreadLocal.ThreadLocalMap threadLocals = null;
    
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    
    private long stackSize;
    
    private long nativeParkEventPointer;
    
    private long tid;
    
    private static long threadSeqNumber;
    
    private volatile int threadStatus = 0;
    
    private static synchronized long nextThreadID() {
        return ++threadSeqNumber;
    }
    
    volatile Object parkBlocker;
    
    private volatile Interruptible blocker;
    private final Object blockerLock = new Object();
    
    void blockedOn(Interruptible b) {
        synchronized (blockerLock) {
            blocker = b;
        }
    }
    
    public final static int MIN_PRIORITY = 1;
    
    public final static int NORM_PRIORITY = 5;
    
    public final static int MAX_PRIORITY = 10;
    
    public static native Thread currentThread();
    
    public static native void yield();
    
    public static native void sleep(long millis) throws InterruptedException;
    
    public static void sleep(long millis, int nanos)
    throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
    
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
    
        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }
    
        sleep(millis);
    }
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null, true);
    }
    
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }
    
        this.name = name;
    
        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();
        if (g == null) {
            if (security != null) {
                g = security.getThreadGroup();
            }
    
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }
    
        g.checkAccess();
    
        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }
    
        g.addUnstarted();
    
        this.group = g;
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();
        this.target = target;
        setPriority(priority);
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        this.stackSize = stackSize;
    
        tid = nextThreadID();
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }
    
    public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
    
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
    Thread(Runnable target, AccessControlContext acc) {
        init(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
    }
    
    public Thread(ThreadGroup group, Runnable target) {
        init(group, target, "Thread-" + nextThreadNum(), 0);
    }
    
    
    public Thread(String name) {
        init(null, null, name, 0);
    }
    
    public Thread(ThreadGroup group, String name) {
        init(group, null, name, 0);
    }
    
    public Thread(Runnable target, String name) {
        init(null, target, name, 0);
    }
    
    public Thread(ThreadGroup group, Runnable target, String name) {
        init(group, target, name, 0);
    }
    
    public Thread(ThreadGroup group, Runnable target, String name,
                  long stackSize) {
        init(group, target, name, stackSize);
    }
    
    
    public synchronized void start() {
    
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
    
        /* 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();
    
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
    
    private void exit() {
        if (group != null) {
            group.threadTerminated(this);
            group = null;
        }
        target = null;
        threadLocals = null;
        inheritableThreadLocals = null;
        inheritedAccessControlContext = null;
        blocker = null;
        uncaughtExceptionHandler = null;
    }
    
    @Deprecated
    public final void stop() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            checkAccess();
            if (this != Thread.currentThread()) {
                security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
            }
        }
        // A zero status value corresponds to "NEW", it can't change to
        // not-NEW because we hold the lock.
        if (threadStatus != 0) {
            resume(); // Wake up thread if it was suspended; no-op otherwise
        }
    
        // The VM can handle all thread states
        stop0(new ThreadDeath());
    }
    
    @Deprecated
    public final synchronized void stop(Throwable obj) {
        throw new UnsupportedOperationException();
    }
    
    public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();
    
        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }
    
    public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }
    
    public boolean isInterrupted() {
        return isInterrupted(false);
    }
    private native boolean isInterrupted(boolean ClearInterrupted);
    
    @Deprecated
    public void destroy() {
        throw new NoSuchMethodError();
    }
    
    public final native boolean isAlive();
    
    @Deprecated
    public final void suspend() {
        checkAccess();
        suspend0();
    }
    
    @Deprecated
    public final void resume() {
        checkAccess();
        resume0();
    }
    
    public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
            throw new IllegalArgumentException();
        }
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) {
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority);
        }
    }
    
    public final int getPriority() {
        return priority;
    }
    public final synchronized void setName(String name) {
        checkAccess();
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }
    
        this.name = name;
        if (threadStatus != 0) {
            setNativeName(name);
        }
    }
    public final String getName() {
        return name;
    }
    public final ThreadGroup getThreadGroup() {
        return group;
    }
    
    public static int activeCount() {
        return currentThread().getThreadGroup().activeCount();
    }
    
    public static int enumerate(Thread tarray[]) {
        return currentThread().getThreadGroup().enumerate(tarray);
    }
    @Deprecated
    public native int countStackFrames();
    
    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;
    
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
    
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }
    
    public final synchronized void join(long millis, int nanos)
    throws InterruptedException {
    
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
    
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
    
        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }
    
        join(millis);
    }
    
    public final void join() throws InterruptedException {
        join(0);
    }
    
    public static void dumpStack() {
        new Exception("Stack trace").printStackTrace();
    }
    public final void setDaemon(boolean on) {
        checkAccess();
        if (isAlive()) {
            throw new IllegalThreadStateException();
        }
        daemon = on;
    }
    
    public final boolean isDaemon() {
        return daemon;
    }
    
    public final void checkAccess() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkAccess(this);
        }
    }
    
    public String toString() {
        ThreadGroup group = getThreadGroup();
        if (group != null) {
            return "Thread[" + getName() + "," + getPriority() + "," +
                           group.getName() + "]";
        } else {
            return "Thread[" + getName() + "," + getPriority() + "," +
                            "" + "]";
        }
    }
    
    @CallerSensitive
    public ClassLoader getContextClassLoader() {
        if (contextClassLoader == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            ClassLoader.checkClassLoaderPermission(contextClassLoader,
                                                   Reflection.getCallerClass());
        }
        return contextClassLoader;
    }
    
    public void setContextClassLoader(ClassLoader cl) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
        }
        contextClassLoader = cl;
    }
    
    public static native boolean holdsLock(Object obj);
    
    private static final StackTraceElement[] EMPTY_STACK_TRACE
        = new StackTraceElement[0];
    public StackTraceElement[] getStackTrace() {
        if (this != Thread.currentThread()) {
            // check for getStackTrace permission
            SecurityManager security = System.getSecurityManager();
            if (security != null) {
                security.checkPermission(
                    SecurityConstants.GET_STACK_TRACE_PERMISSION);
            }
            // optimization so we do not call into the vm for threads that
            // have not yet started or have terminated
            if (!isAlive()) {
                return EMPTY_STACK_TRACE;
            }
            StackTraceElement[][] stackTraceArray = dumpThreads(new Thread[] {this});
            StackTraceElement[] stackTrace = stackTraceArray[0];
            // a thread that was alive during the previous isAlive call may have
            // since terminated, therefore not having a stacktrace.
            if (stackTrace == null) {
                stackTrace = EMPTY_STACK_TRACE;
            }
            return stackTrace;
        } else {
            // Don't need JVM help for current thread
            return (new Exception()).getStackTrace();
        }
    }
    
    public static Map<Thread, StackTraceElement[]> getAllStackTraces() {
        // check for getStackTrace permission
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkPermission(
                SecurityConstants.GET_STACK_TRACE_PERMISSION);
            security.checkPermission(
                SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
        }
    
        // Get a snapshot of the list of all threads
        Thread[] threads = getThreads();
        StackTraceElement[][] traces = dumpThreads(threads);
        Map<Thread, StackTraceElement[]> m = new HashMap<>(threads.length);
        for (int i = 0; i < threads.length; i++) {
            StackTraceElement[] stackTrace = traces[i];
            if (stackTrace != null) {
                m.put(threads[i], stackTrace);
            }
            // else terminated so we don't put it in the map
        }
        return m;
    }
    
    
    private static final RuntimePermission SUBCLASS_IMPLEMENTATION_PERMISSION =
                    new RuntimePermission("enableContextClassLoaderOverride");
    private static class Caches {
        static final ConcurrentMap<WeakClassKey,Boolean> subclassAudits =
            new ConcurrentHashMap<>();
    
        static final ReferenceQueue<Class<?>> subclassAuditsQueue =
            new ReferenceQueue<>();
    }
    private static boolean isCCLOverridden(Class<?> cl) {
        if (cl == Thread.class)
            return false;
    
        processQueue(Caches.subclassAuditsQueue, Caches.subclassAudits);
        WeakClassKey key = new WeakClassKey(cl, Caches.subclassAuditsQueue);
        Boolean result = Caches.subclassAudits.get(key);
        if (result == null) {
            result = Boolean.valueOf(auditSubclass(cl));
            Caches.subclassAudits.putIfAbsent(key, result);
        }
    
        return result.booleanValue();
    }
    
    private static boolean auditSubclass(final Class<?> subcl) {
        Boolean result = AccessController.doPrivileged(
            new PrivilegedAction<Boolean>() {
                public Boolean run() {
                    for (Class<?> cl = subcl;
                         cl != Thread.class;
                         cl = cl.getSuperclass())
                    {
                        try {
                            cl.getDeclaredMethod("getContextClassLoader", new Class<?>[0]);
                            return Boolean.TRUE;
                        } catch (NoSuchMethodException ex) {
                        }
                        try {
                            Class<?>[] params = {ClassLoader.class};
                            cl.getDeclaredMethod("setContextClassLoader", params);
                            return Boolean.TRUE;
                        } catch (NoSuchMethodException ex) {
                        }
                    }
                    return Boolean.FALSE;
                }
            }
        );
        return result.booleanValue();
    }
    
    private native static StackTraceElement[][] dumpThreads(Thread[] threads);
    private native static Thread[] getThreads();
    public long getId() {
        return tid;
    }
    
    public enum State {
    public State getState() {
        // get current thread state
        return sun.misc.VM.toThreadState(threadStatus);
    }
    
    // Added in JSR-166
    
    
    @FunctionalInterface
    public interface UncaughtExceptionHandler {
        /**
         * Method invoked when the given thread terminates due to the
         * given uncaught exception.
         * <p>Any exception thrown by this method will be ignored by the
         * Java Virtual Machine.
         * @param t the thread
         * @param e the exception
         */
        void uncaughtException(Thread t, Throwable e);
    }
    
    // null unless explicitly set
    private volatile UncaughtExceptionHandler uncaughtExceptionHandler;
    
    // null unless explicitly set
    private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;
    
    public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(
                new RuntimePermission("setDefaultUncaughtExceptionHandler")
                    );
        }
    
         defaultUncaughtExceptionHandler = eh;
     }
    
    public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler(){
        return defaultUncaughtExceptionHandler;
    }
    
    public UncaughtExceptionHandler getUncaughtExceptionHandler() {
        return uncaughtExceptionHandler != null ?
            uncaughtExceptionHandler : group;
    }
    
    public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
        checkAccess();
        uncaughtExceptionHandler = eh;
    }
    
    private void dispatchUncaughtException(Throwable e) {
        getUncaughtExceptionHandler().uncaughtException(this, e);
    }
    
    static void processQueue(ReferenceQueue<Class<?>> queue,
                             ConcurrentMap<? extends
                             WeakReference<Class<?>>, ?> map)
    {
        Reference<? extends Class<?>> ref;
        while((ref = queue.poll()) != null) {
            map.remove(ref);
        }
    }
    
    static class WeakClassKey extends WeakReference<Class<?>> {
        private final int hash;
    
        WeakClassKey(Class<?> cl, ReferenceQueue<Class<?>> refQueue) {
            super(cl, refQueue);
            hash = System.identityHashCode(cl);
        }
    
        @Override
        public int hashCode() {
            return hash;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (obj == this)
                return true;
    
            if (obj instanceof WeakClassKey) {
                Object referent = get();
                return (referent != null) &&
                       (referent == ((WeakClassKey) obj).get());
            } else {
                return false;
            }
        }
    }
    
    
    /** The current seed for a ThreadLocalRandom */
    @sun.misc.Contended("tlr")
    long threadLocalRandomSeed;
    
    /** Probe hash value; nonzero if threadLocalRandomSeed initialized */
    @sun.misc.Contended("tlr")
    int threadLocalRandomProbe;
    
    /** Secondary seed isolated from public ThreadLocalRandom sequence */
    @sun.misc.Contended("tlr")
    int threadLocalRandomSecondarySeed;
    
    private native void setPriority0(int newPriority);
    private native void stop0(Object o);
    private native void suspend0();
    private native void resume0();
    private native void interrupt0();
    private native void setNativeName(String name);
    

    }

    展开全文
  • 多线程启动线程数计算公式

    千次阅读 2018-01-01 21:15:49
    启动线程数 = 【任务执行时间/(任务执行时间-IO等待时间)】*CPU内核数
  • 线程池是如何启动线程

    千次阅读 2019-11-17 17:52:48
    啃完小龙虾掐指一算,周末又要结束了,赶紧来记录并分享点东西… … … 日常工作中多多少少都会需要用多线程去处理一些事情,下面就来记录并分享下线程池启动线程相关的知识: 一、线程池的好处 合理利用线程池会...
  • 易语言的启动线程默认是传递一个整数的,在易语言启动线程传递文本参数中,我们讲解了传递文本参数,今天,我们示范传递多个变量 思路是我们把要传递的变量定义成一个整数型数组,传递的是参数内容的内存地址指针,...
  • Java中启动线程start和run方法

    千次阅读 2018-07-21 21:31:44
    Java中启动线程有两种方法,继承Thread类和实现Runnable接口,由于Java无法实现多重继承,所以一般通过实现Runnable接口来创建线程。但是无论哪种方法都可以通过start()和run()方法来启动线程,下面就来介绍一下他们...
  • 多线程传参-数组传参 1、传递数组变量 2、取变量数据地址()... 启动线程 (&子程序1, 取变量数据地址 (文本数组 [n]), t) 等待线程 (t, 10) .计次循环尾 () .子程序 子程序1 .参数 a_address, 整数型 .局部...
  • java多线程之启动线程的三种方式

    万次阅读 多人点赞 2018-08-12 14:42:08
    java对多线程有着良好的支持,java创建和启动线程较为常用的方式有继承Thread类、实现Runnable接口和匿名内部类的方式。 1.继承Thread类: 通过继承Thread类来创建并启动多线程步骤如下: 1、定义Thread类的子类...
  • 易语言封装的启动线程是无法传递文本参数的,我们可以为这个要传递的文本申请一个内存地址,把这个地址传递过去,下面通过演示和封装来说明实现过程。 演示传递文本参数 1、创建一个文本型的变量,来存储要传递的...
  • 线程的实现(通过实现Runnable接口启动线程
  • 子程序 _按钮_开始_被单击, , , 绑定,启动线程 .局部变量 n, 整数型 .局部变量 索引, 整数型 .局部变量 句柄, 整数型 .判断开始 (按钮_开始.标题 = “全部开始”) 按钮_开始.标题 = “全部停止” 超级延时 ...
  • 创建和启动线程的两种方式

    万次阅读 多人点赞 2016-10-07 10:52:48
    方式1:继承Thread类 步骤: 1):定义一个类A继承于java.lang.Thread类. 2):在A类中覆盖Thread类中的run方法. ...4):在main方法(线程)中,创建线程对象,并启动线程. (1)创建线程类对象: A类 a = new A类();
  • C++程序中启动线程的方法

    万次阅读 2017-11-13 09:33:43
    C++11 引入一个全新的线程库,包含启动和管理线程的工具,提供了同步(互斥、锁和原子变量)的方法,我将试图为你介绍这个全新的线程库。...启动线程 在 C++11 中启动一个线程是非常简单的,你可以使用 std:thr
  • 线程启动会通过调用start方法来启动线程而不能直接调用run方法。 这里就会引出两个经典的面试题: 为什么线程启动是调用start方法来启动线程而不能直接调用run方法? 如果多次调用start方法会发生什么? 其实...
  • 启动线程的第三种方式之Callable

    千次阅读 2018-04-29 15:06:38
    java中第三种启动线程的方式是实现Callable接口package com.lyzx.juc; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; ...
  • jmeter jp@gc - Stepping Thread Group (deprecated)-自定义启动线程 比较好的自定义线程组,在这里可以简单认识一下参数 但是官方已经明确弃用,使用 Concurrency Thread Group代替 This group will start:总...
  • 1、启动线程方式: 要启动的可以分为两类:返回结果和不返回结果。对于这两种,也分别有两种启动线程的方式: 1)继承Thread类,implements Runnable接口 2)实现Callable接口通过FutureTask包装器来创建Thread...
  • 线程传参自定义数据 • 1、自定义数据类型 • 2、传递自定义数据类型的指针 • 3、把数据内存指针转换为新数据内存指针 • 4、赋给新的自定义数据变量源码: .子程序 子程序1 .参数 a, 整数型 .局部变量 C, ...
  • 线程 创建和启动线程的两种方式 实现Runnable接口 继承Thread类 重写唯一方法run() 1.实现Runnable接口,必须重写Runnable接口的唯一run()方法。 启动线程的方法(在主程序中):启动线程需要由三步来执行。 1).首先...
  • Java启动线程两种方式总结

    千次阅读 2018-07-12 14:40:48
    先查看jdk帮助文档,这么进行描述线程线程是程序中的执行线程,可以由jvm来运行一个或者多个线程。 方法1:继承Thread 类 重写run方法即可 如下代码: public class Treadtest { //主方法 public static...
  • 多线程以及几种启动线程的方式

    千次阅读 2019-05-10 21:18:38
    线程进程和线程线程线程启动方式方式一方式二方式三方式四 进程和线程 进程和线程: 进程:正在执行的程序。 线程:一条独立的执行路径。 一个进程可以只有一条线程,也可以有多条线程。 多线程 Java中至少...
  • Java启动线程的三种方式

    千次阅读 2019-10-24 19:02:22
    Thread 继承自Thread。 public class ThreadDemo extends Thread { @Override ... System.out.println(Thread.currentThread().getName() + "-启动了..."); } public static void main(String[] arg...
  • 创建并启动线程几种方式

    千次阅读 2017-12-14 23:26:12
    一:创建线程的几种方式 1.第一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法,然后在run方法里填写相应的逻辑代码。class ThreadDemo1 extends Thread{ @Override public void run() {...
  • 问题来了,如何在关闭窗体时,启动线程的进程也相应的关闭? 1、之前在百度和谷歌都收了 下,很多人都说,创建子线程后,只需在启动前将isBackground置为true,那么就可以了,后来我去试了下,没实现想要的结果...
  • python 启动线程的两种方法

    千次阅读 2019-01-28 16:52:23
    Python调用线程有两种情况,一种是在主线程中直接调用,还一种是直接在其他方法中调用线程 在传递参数的方式上有所区别,两种调用方法如下: 1. 主进程中直接调用线程: from threading import Thread import ...
  • 首先Thread类中run()和start()方法的区别如下: ... start()方法:启动一个线程,调用该Runnable对象的run()方法,不能多次启动一个线程; public class Test implements Runnable{ public st...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 959,013
精华内容 383,605
关键字:

如何启动线程