澳门新葡亰娱乐网站-www.142net-欢迎您

澳门新葡亰娱乐网站是因为你还没有找到一条正确的致富之路,www.142net是将所有的游戏都汇集在一起的官方平台,因为澳门新葡亰娱乐网站这个网站当中有着大量的游戏攻略,托IP定位技术,传达终端直接到达的精准传播方式。

多少个线程,线程的2种完毕和线程的更替实行新

来源:http://www.bhtsgq.com 作者:计算机知识 人气:177 发布时间:2019-05-30
摘要:明日去了回客科学技术 笔试了一波。很不满啊,脑袋有思路不过还没到手写代码很在行的档次,基本功不做到。 线程的2种完毕和线程的轮换实施,线程2种交替执行 多少个线程,线程的

明日去了回客科学技术 笔试了一波。很不满啊,脑袋有思路 不过还没到手写代码很在行的档次,基本功不做到。

线程的2种完毕和线程的轮换实施,线程2种交替执行

多少个线程,线程的2种完毕和线程的更替实行新葡萄京官网:。学了线程,收获累累,记录下了吧.

一、线程的根本两种完结格局。

1.继承Thread类,重写run()方法  

   main方法中开创子类,引用调用start()方法

实比如下:

//继承Thread类,重写run()方法      

public class ThreadOne extends Thread {

public void run() {
for (int i = 1; i <=100; i ) {
System.out.println(this.getName() ":" i);
}
}

public static void main(String[] args) {
//创建Thread对象
ThreadOne threadOne = new ThreadOne();
//调用start()
threadOne.start();

}

}

2.实现Runnable()接口,实现run()方法。

 mian方法中 实例该类,实例Thread类并装有该类的引用 Thread的引用调用start().

实例:

//实现Runnable()接口,实现run()方法

public class MyThread implements Runnable {
public void run() {
for(int i=0; i<10; i ){
System.out.println(Thread.currentThread().getName() "放入三个苹果:" i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}

public static void main(String[] args) {

//创建MyThread类
MyThread myThread =new MyThread();

//创建Thread,并持有MyThread的应用
Thread thread = new Thread(myThread);

//调用start()
thread.start();
}
}

二.规律交替实行线程标题

举例难题:完毕七个线程能够交替每隔1分钟打字与印刷叁次时间,每种线程打字与印刷七次后截至线程

结果要求:

Thread-0 Sun Feb 28 11:21:52 CST 2016;
Thread-1 Sun Feb 28 11:21:53 CST 2016
Thread-0 Sun Feb 28 11:21:54 CST 2016
Thread-1 Sun Feb 28 11:21:55 CST 2016
Thread-0 Sun Feb 28 11:21:56 CST 2016
Thread-1 Sun Feb 28 11:21:57 CST 2016
Thread-0 Sun Feb 28 11:21:58 CST 2016
Thread-1 Sun Feb 28 11:21:59 CST 2016
Thread-0 Sun Feb 28 11:22:00 CST 2016
Thread-1 Sun Feb 28 11:22:01 CST 2016

主题材料深入分析:

第二要 落成1个线程:功用皆以开创时间;其次要求交替实施,就非得加锁synchronized;这一个都是能够精通的

重大的是以此锁怎么决定,用什么决定,采取方法为:定义一个static状态值 state ,取值为一,贰;

当state=一的时候,实行线程一,线程二等待,试行实现后将state=2,并调用notifyAll() 也许notify()方法;

当state=二的时候,试行线程二,线程一等待,施行完毕后将state=一,并调用notifyAll() 或许notify()方法;

最终就剩调控5次的主题材料了,各自定义1个static int 变量 利用while调整呗,各线程试行三回,相应的变量值加一到五达成

代码:

public class ThreadDate{
//状态值 调整 推行哪个程序用
private static int state =1;
//调节线程壹奉行的次数
private static int num1 =1;
//调控线程2施行的次数
private static int num2 =1;
public static void main(String[] args) {
//用该类作为锁
final ThreadDate t= new ThreadDate();
//创建第七个线程,并调用start()方法
new Thread(new Runnable() {
public void run() {
//用while num壹调整实行次数
while(num1<=5){
//加锁
synchronized (t) {
//首先应状态值判定是或不是该实施
if(state!=1){
try {
t.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() " " new Date());

try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//执行完成,状态值改换
state =2;
t.notifyAll();
}
num1 ;
}
}
}).start();;

//成立第贰个线程,并调用start()方法
new Thread(new Runnable() {
public void run() {
while(num2<=5){
synchronized (t) {
if(state!=2){
try {
t.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() " " new Date());

try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

state =1;
t.notifyAll();
}
num2 ;
}
}
}).start();
}
}

 

学了线程,收获累累,记录下了吧. 壹、线程的关键二种达成格局。 1.继承Thread类,重...

import java.util.*;
public class Main {
    static ArrayList<Integer> list=new ArrayList<Integer>();
    private static Object lock=new Object();
    private static int a=1;
    private static int b=1;
    static boolean bool=true;
    public static void main(String[] args)
    {
        Thread t1=new Thread(){
            public void run()
            {
                for(int i=0;i<10;i  )
                {
                    synchronized(lock)
                    {                        
                        a*=3;
                        list.add(a);
                        bool=false;
                        lock.notify();//唤醒一个线程
                        try
                        {
                            lock.wait();//挂起该线程
                        }
                        catch(InterruptedException e)
                        {
                                e.printStackTrace();
                        }

                    }
                }
            }
        };
        Thread t2=new Thread(){
            public void run()
            {
                for(int i=0;i<10;i  )
                {
                    synchronized(lock){
                        if(bool)
                        {
                            try{
                                lock.wait();
                            }
                            catch(InterruptedException e)
                            {
                                e.printStackTrace();
                            }
                        }
                        b*=7;
                        list.add(b);
                        bool=true;
                        lock.notifyAll();//唤醒所有等待线程(同一个锁上)
                    }
                }
            }

        };
        t1.start();
        t2.start();
        try
        {
            t1.join();
            t1.join();
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
        for(int i=0;i<list.size();i  )
        {
            System.out.println(list.get(i));
        }
    }

}

早就有面试官问过那样八个主题材料,怎么着让多个线程交替打字与印刷奇数和偶数?如何让七个线程交替推行?

先是道:线程的题:八个线程 一 一个线程 -一 运算 。

 

回应那一个标题从前须求先驾驭java十二线程的运维机制,线程间通讯机制,线程同步问题。

探望互连网还恐怕有七个线程的,五个加法总括,八个减法运算。基本的笔触都是均等的 ,注意看一块管理。

其①主题素材自身清楚的贯彻方案有三种,一种是依靠synchronized和wait/notify,其余1种是依据Lock和Condition.

上边贴出代码完成:

1.基于synchronized和wait/notify

public class AddTest {


    private static int i;

    private static Object object = new Object();

    public static void main(String[] args) {


        new Thread(() -> {
            synchronized (object) {
                i  ;
            }
        }).start();

        new Thread(() -> {
            synchronized (object) {
                i  ;
            }

        }).start();

        new Thread(() -> {
            synchronized (object) {
                i  ;
            }
        }).start();

        new Thread(() -> {
            synchronized (object) {
                i--;
            }
        }).start();
//这里睡眠 等所有线程运行完毕 看最终的数值,2
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(i);

    }
}

package org.stathry.jdkdeep.concurrent;

 这里引申出来了任何难题的理念

/**

第1种:
synchronized void add  修饰普通方法 等同于

synchronized (this)

  public int i = 0;

    public void add(String threadName) {
        synchronized (this) {
            i  ;
            System.out.println(threadName   "加法运算:"   i);
        }
    }

//上面代码等于如下代码:

   public synchronized void add(String threadName) {

            i  ;
            System.out.println(threadName   "加法运算:"   i);

    }

* 线程间通讯-基于Object的wait/notify

  

* @date 2017年12月21日

第2种:
synchronized static void add  修饰静态方法 等同于

synchronized (*.class)

说明:以上两种我分析为 synchornized 修饰普通方法和this 对应的是同一个实例对象。而修饰静态方法和class 是对应的同一个类的 唯一的class对象。这个是我的理解,有错误之处请各位指正。在此谢过

第二道:一个线程加一运算,一个线程做减法运算,多个线程同时交替运行(延申的)

第1种方法:使用Synchronized 实现

public class Count {
    private int num = 0;
    private boolean flag = false; // 标识

    //加法
    public synchronized void add() {
        while (flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.num  ; //加
        System.out.println(Thread.currentThread().getName()   "........"   this.num);
        this.flag = true; //设置标识为true
        notifyAll(); //唤醒所有在线程池中冻结的线程,会把所有都唤醒

    }

    //减法
    public synchronized void sub() {
        while (!flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.num--; //减
        System.out.println(Thread.currentThread().getName()   "........"   this.num);
        this.flag = false; //设置标识为true
        notifyAll(); //唤醒所有在线程池中冻结的线程,会把所有都唤醒
    }
}

*/

 第2种 :使用Lock 锁实现

public class ThreadTurnTest1 {

 

private Object lock = new Object();

public class CountLock {

    private int num = 0;
    private boolean flag = false; // 标识
    Lock lock = new ReentrantLock(); // 锁
    Condition add = lock.newCondition(); // 加法锁
    Condition sub = lock.newCondition();// 减法锁

    public void add() {
        lock.lock();// 锁上
        try {
            while (flag) {  //循环判断

                add.await();
            }
            this.num  ;
            System.out.println(Thread.currentThread().getName()   "........"   this.num);
            this.flag = true; // 设置标识
            sub.signal(); // 唤醒指定线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void sub() {
        lock.lock();// 锁上
        try {
            while (!flag) {//循环判断
                sub.await();
            }
            this.num--;
            System.out.println(Thread.currentThread().getName()   "........"   this.num);
            this.flag = false; // 设置标识
            add.signal(); // 唤醒指定线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

private boolean RUN0 = true;

  

private static final int LIMIT = 1000;

调用的 main 方法:

    public static void main(String[] args) {
        //Count c=new Count();
        CountLock c=new CountLock();

        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    c.add();
                }
            }
        });
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    c.sub();
                }

            }
        });

        t1.start();
        t2.start();
   //这里感觉线程少可以再启动 两个t3或者t4 来验证真实性

    }

public static void main(String[] args) throws InterruptedException {

  

final ThreadTurnTest1 o = new ThreadTurnTest1();

这里延申的知识点参考博客:

new Thread(new Runnable() {

2个线程加一运算,贰个线程做减一运算,多个线程同一时间交替运转--synchronized

@Override

java synchronized修饰普通方法,修饰静态方法,修饰代码块,修饰线程run方法 比较

public void run() {

try {

o.m0();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "t0").start();

new Thread(new Runnable() {

@Override

public void run() {

try {

o.m1();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "t1").start();

Thread.sleep(10 * 1000);

}

private void m1() throws InterruptedException {

for (int i = 1; i < LIMIT; i = 2) {

synchronized {

if {

lock.wait();

}

System.out.println(Thread.currentThread().getName() "___" i);

RUN0 = true;

lock.notify();

}

本文由澳门新葡亰发布于计算机知识,转载请注明出处:多少个线程,线程的2种完毕和线程的更替实行新

关键词: Java 多线程 多个 线程

上一篇:没有了

下一篇:没有了

最火资讯