黑马程序员——Java基础---多线程

最新推荐文章于 2015-12-07 14:27:34 发布
最新推荐文章于 2015-12-07 14:27:34 发布
阅读量299 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010114620/article/details/46761267
版权

　——- android培训、java培训、期待与您交流！ ———-
　一：进程与线程的概念
进程：进程是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元
线程：线程就是进程中一个独立的控制单元，线程再控制着进程的执行。
一个进程中至少有一个线程。
JVM启动时启动了多条线程，至少有两个线程：
1.执行main函数的线程，该线程的任务代码都定义在main函数中。
2.负责垃圾回收的线程。

二.线程的创建
如何在自定义的代码中，自定义一个线程呢？
通过对api的查找，java已经提供了对这类事物的描述，就是Thread类。
1.创建线程的第一种方式：继承Thread类。
步骤：
1，定义类继承Thread.
2,复写Thread类中Run方法。
目的：将自定义代码存储在run方法中，让线程运行。
3.调用线程中start(此方法有两个作用：执行线程并调用Run方法)

package Thread;

class Demo extends Thread
{
    public void run()
    {
        for(int x =0; x<800; x++)
        System.out.println("demo");
    }
}
public class ThreadDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Demo d=new Demo();
        d.start();

        for(int x=0; x<800;x++)
        {
            System.out.println("hello Thread"+x);
        }
    }

}

结果：这里写图片描述
发现：运行结果每一次都不同。因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行。
明确一点：在某个时刻，只能有一个程序在运行。（多核除外）cpu在做着快速的切换，以达到看上去是同时运行的效果。我们可以形象地把多线程的运行行为比喻为互相抢夺cpu的执行权。
这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，由cpu决定。

为什么要覆盖run方法呢？
Thread类用于描述线程，该类就定义了一个动能，用于存储线程要运行的代码，该存储功能就是Run方法。也 就是是说Thread类中run方法用于存储线程要运行的代码。

/*
 * 练习：创建两个线程，和柱线程交互运行
 */
package Thread;

class Test extends Thread
{
    public void run()
    {
        for(int x=0; x<500; x++)
        System.out.println("test run"+x);
    }
}
public class ThreadTest {

    public static void main(String[] args) {
        new Test().start();
        new Test().start();

        for(int x=0; x<200; x++)
        {
            System.out.println("ThreadTest run"+x);
        }
    }

}

结果：这里写图片描述

static Thread currentThread():获取当前线程对象
getName():获取线程名称
设置线程名称：setName或者构造函数

package Thread;

class Test extends Thread
{
    //通过构造函数设置线程名
    Test(String name)
    {
        super(name);
    }
    public void run()
    {
        for(int x=0; x<500; x++)
        System.out.println("test run"+","+this.getName()+x);//通过this或者CurrentThread.getName()获取线程名
    }
}
public class ThreadTest {

    public static void main(String[] args) {
        new Test("one...").start();
        new Test("two....").start();

        for(int x=0; x<200; x++)
        {
            System.out.println("ThreadTest run"+x);
        }
    }

}

结果：这里写图片描述

2.创建线程的第二种方式：实现Runable接口
步骤：
1.定义类实现Runable接口
2.覆盖Runable接口中run方法。将线程要运行的代码存放在该run方法中
3.通过Thread类建立线程对象。
4.将Runable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runable接口的子类对象传递给Thread的构造函数。因为，自定义的run方法所属的对象是Runable接口的子类对象，所以要让线程去指定对象的run方法。就必须明确该run方法所属的对象。
5.调用Thread类的start方法开启线程并调用Runable接口子类的run方法。

示例：

/*
 * 需求：简单的买票程序，多个窗口同时卖票
 */
package Thread;

class Ticket implements Runnable //创建一个类实现Runnable接口
{
    private int tick=100;
    //覆盖接口中的run方法
        public void run()
    {
        while(true)
        {
            if(tick>0)
            {
                System.out.println(Thread.currentThread().getName()+"sale..."+tick--);

            }

        }

    }
}
public class TicketTest {

    public static void main(String[] args) {
            Ticket t=new Ticket()//建立实现runnable接口的类的对象

        Thread t1=new Thread(t);//创建Thread对象，并将实现类的对象作为参数传入构造函数中
        t1.start();      //调用start()方法开启线程并运行run方法
        Thread t2=new Thread(t);
        t2.start();
        Thread t3=new Thread(t);
        t3.start();
        Thread t4=new Thread(t);
        t4.start();



    }

}

输出结果：这里写图片描述

实现方式和继承方式有什么区别呢？
实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。

三.多线程的安全问题
还是四条线程卖票示例模拟线程安全问题：

package Thread;

class Ticket implements Runnable
{
    private int tick=100;
    public void run()
    {
        while(true)
        {
            if(tick>0)
            {
                try {
                    Thread.sleep(10); //让线程睡眠，模拟线程安全问题
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"sale..."+tick--);

            }

        }

    }
}
public class TicketTest {

    public static void main(String[] args) {
        Ticket t=new Ticket();

        Thread t1=new Thread(t);
        t1.start();
        Thread t2=new Thread(t);
        t2.start();
        Thread t3=new Thread(t);
        t3.start();
        Thread t4=new Thread(t);
        t4.start();

    }

}

输出结果：这里写图片描述
发现：打印出0，-1，等错票，说明多线程的运行出现了安全问题

问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线 程参与进来执行，导致共享数据的错误
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
java对于多线程的安全问题提供了专业的解决方式：同步代码块。
synchronized(对象）
{
需要被同步的代码
}
加锁示例：

package Thread;

class Ticket implements Runnable
{
    private int tick=100;
    Object obj=new Object();
    public void run()
    {
        while(true)
        {
            synchronized(obj){
            if(tick>0)
            {

                try {
                    Thread.sleep(10); //让线程睡眠，模拟线程安全问题
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"sale..."+tick--);
            }
                        }
        }



    }
}
public class TicketTest {

    public static void main(String[] args) {
        Ticket t=new Ticket();

        Thread t1=new Thread(t);
        t1.start();
        Thread t2=new Thread(t);
        t2.start();
        Thread t3=new Thread(t);
        t3.start();
        Thread t4=new Thread(t);
        t4.start();

    }

}

输出结果：这里写图片描述
对象如同锁，持有锁的进程可以在同步中执行。没有持有锁的进程及时获取cpu的
执行权，也进不去，因为没有获取权限。

同步的前提：
1.必须要有两个或两个以上的线程。
2.必须是多个线程使用同一个锁。
3.必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。

同步函数

package Thread;
/*
 * 需求：
 * 银行有一个金库。有两个储户分别存300元，每次存100，存10次。
 * 目的：该程序是否有安全问题，如果有，如何解决
 * 
 * 如何找问题：
 * 1，明确哪些代码是多线程运行代码
 * 2.明确共享数据
 * 3.明确多线程运行代码中哪些语句是操作共享数据的。
 */
class Bank
{
    private int sum;
    public  synchronized void  add(int n) //同步函数
    {
        sum=sum+100;
        System.out.println("sum="+sum);
    }
}
class Cus implements Runnable
{
    Bank b=new Bank();

    public void run()
    {
        for(int x=0; x<11; x++)
        {
            b.add(100);
        }
    }
}
 class BankDemo {

    public static void main(String[] args) {

        Cus c=new Cus();
        Thread t1=new Thread(c);
        Thread t2=new Thread(c);
        t1.start();
        t2.start(); 
    }
}

输出结果：这里写图片描述

同步函数用的是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象引用，就是this.所以同步函数使用的锁是this。

静态函数使用的锁：
静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件（类名.class）对象，该对象的类型是class，静态的同步方法使用的锁是该方法所在类的字节码文件对象

多线之应用：懒汉式：

package Thread;
class Single
{
    private static Single s=null;
    private Single(){};
    public static Single getSingle()
    {
        //双重判断，提高效率
        if(s==null)
        {
            //通过所解决线程安全问题
            synchronized(Single.class) 
            {
                if(s==null)
                {
                    s=new Single();
                }

            }
        }
        return s;
    }

}
public class SingleDemo {

    public static void main(String[] args) {
        Single.getSingle();
    }

}
package Thread;
/*
 * 死锁
 */
class  Testlock implements Runnable
{
    private boolean flag;
    Testlock(boolean flag)
    {
        this.flag=flag;
    }
    public void run()
    {
        if(flag)
        {
            synchronized (Lock.locka) 
            {
                System.out.println("if locka");

                synchronized (Lock.lockb)
                {
                    System.out.println("if lockb");
                }
            }
        }
        else
            synchronized (Lock.lockb) 
            {
                System.out.println("else lockb");

                synchronized (Lock.locka)
                {
                    System.out.println("else locka");
                }
            }

    }

四.多线程通信

package Thread;

//定义一个资源
class Res
{
    String name;
    String sex;
}

//定义类输入资源
class Input implements Runnable
{
    private Res r;
    Input(Res r)
    {
        this.r=r;
    } 
    public void run()
    {
        int x=0;
        while(true)
        {
            if(x==0)
            {
                r.name="mike";
                r.sex="man";
            }
            else
            {
                r.name="丽丽";
                r.sex="女女女女女";
            }
            x=(x+1)%2;
        }

    }

}
//定义类输出资源
class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r=r;
    }
    public void run() {
        while(true)
        {
            System.out.println(r.name+"..."+r.sex);

        }
    }

}
public class IntOutputDemo {

    public static void main(String[] args) {
        Res r=new Res();

        Input in=new Input(r);
        Output out=new Output(r);

        Thread t1=new Thread(in); //输入线程
        Thread t2=new Thread(out);//输出线程

        t1.start();//开启输出线程并运行run方法
        t2.start();//开启输出线程并运行run方法


    }

}

输出结果：这里写图片描述
从结果可见多线通信存在安全问题

解决安全问题：加锁

//定义一个资源
class Res
{
    String name;
    String sex;
}

//定义类输入资源
class Input implements Runnable
{
    private Res r;
    Input(Res r)
    {
        this.r=r;
    } 
    public void run()
    {
        int x=0;
        while(true)
        {
            synchronized (r) {
                if(x==0)
                {
                    r.name="mike";
                    r.sex="man";
                }
                else
                {
                    r.name="丽丽";
                    r.sex="女女女女女";
                }
                x=(x+1)%2;
            }

        }

    }

}
//定义类输出资源
class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r=r;
    }
    public void run() {
        while(true)
        {
            synchronized (r) {
                System.out.println(r.name+"..."+r.sex);
            }
        }
    }

}
public class IntOutputDemo {

    public static void main(String[] args) {
        Res r=new Res();

        Input in=new Input(r);
        Output out=new Output(r);

        Thread t1=new Thread(in); //输入线程
        Thread t2=new Thread(out);//输出线程

        t1.start();//开启输出线程并运行run方法
        t2.start();//开启输出线程并运行run方法
    }

}

结果：这里写图片描述

等待唤醒机制
wait(); 等待
notify(); 唤醒
notifyAll(); 唤醒全部
这些都使用在同步中，因为要对持有监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程方法要定义在Object类中呢？
因为这些方法在操作同步中的线程时，都必须要标示它们所操作线程持有的锁，只有同一个锁的
被等待线程，可以被同一个锁上notify唤醒。不可以对不同锁中线程进行唤醒。也即是说等待和
唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义在object类中。
示例：

package Thread;

//定义一个资源
class Res
{
    String name;
    String sex;
    boolean flag=false;
}

//定义类输入资源
class Input implements Runnable
{
    private Res r;
    Input(Res r)
    {
        this.r=r;
    } 
    public void run()
    {
        int x=0;
        while(true)
        {
            synchronized (r) {
                if(r.flag)
                    try {
                        r.wait(); //等待
                    } catch (InterruptedException e) {}
                if(x==0)
                {
                    r.name="mike";
                    r.sex="man";
                }
                else
                {
                    r.name="丽丽";
                    r.sex="女女女女女";
                }
                x=(x+1)%2;
                r.flag=true;
                r.notify(); //唤醒
            }

        }

    }

}
//定义类输出资源
class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r=r;
    }
    public void run() {
        while(true)
        {
            synchronized (r) {
                if(!r.flag)
                    try {
                        r.wait();//等待
                    } catch (InterruptedException e) {}
                System.out.println(r.name+"..."+r.sex);
                r.flag=false;
                r.notify();//唤醒
            }
        }
    }

}
public class IntOutputDemo {

    public static void main(String[] args) {
        Res r=new Res();

        Input in=new Input(r);
        Output out=new Output(r);

        Thread t1=new Thread(in); //输入线程
        Thread t2=new Thread(out);//输出线程

        t1.start();//开启输出线程并运行run方法
        t2.start();//开启输出线程并运行run方法
    }

}

结果：这里写图片描述

优化代码：

package Thread;

//定义一个资源
class Res
{
    private String name;
    private String sex;
    private boolean flag=false;

    public synchronized void set(String name,String sex)
    {
        if(flag)
            try {this.wait();} catch (Exception e) {        
            }
        this.name=name;

        this.sex=sex;
        flag=true;
        this.notify();
    }
    public synchronized void out()
    {
        if(!flag)
            try {this.wait();} catch (Exception e) {        
            }
        System.out.println(name+"........"+sex);
        flag=false;
        this.notify();
    }
}

//定义类输入资源
class Input implements Runnable
{
    private Res r;
    Input(Res r)
    {
        this.r=r;
    } 
    public void run()
    {
        int x=0;
        while(true)
        {

                if(x==0)
                    r.set("mike","man");
                else 
                    r.set("丽丽","女");

                x=(x+1)%2;                          
        }

    }

}
//定义类输出资源
class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r=r;
    }
    public void run() {
        while(true)
        {
            r.out();
        }
    }

}
public class IntOutputDemo {

    public static void main(String[] args) {
        Res r=new Res();

        //用匿名对象简化代码
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();
        /*
        Input in=new Input(r);
        Output out=new Output(r);

        Thread t1=new Thread(in); //输入线程
        Thread t2=new Thread(out);//输出线程

        t1.start();//开启输出线程并运行run方法
        t2.start();//开启输出线程并运行run方法
        */
    }

}

输出结果
这里写图片描述

示例二：生产者与消费者

package Thread;

public class ProduceConsumerDemo {

    public static void main(String[] args) {
        Resource r=new Resource();

        Producer pro=new Producer(r);
        Consumer con =new Consumer(r);

        Thread t1=new Thread(pro);
        Thread t2=new Thread(pro);
        Thread t3=new Thread(con);
        Thread t4=new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}
class Resource
{
    private String name;
    private int count=1;
    private boolean flag=false;
    public synchronized void set(String name)
    {
        while(flag)
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        this.name=name+"--"+count++;
        System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
        flag=true;
        this.notifyAll(); 
    }
    public synchronized void out()
    {
        while(!flag)
            try {
                wait();
            } catch (InterruptedException e) {          
                e.printStackTrace();
            }
        System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
        flag=false;
        this.notifyAll();
    }
}
class Producer implements Runnable
{
    private Resource res;
    Producer(Resource res)
    {
        this.res=res;
    }
    public void run() {
        while(true)
        {
            res.set("+商品+");
        }
    }

}
class Consumer implements Runnable
{
    private Resource res;
    Consumer(Resource res)
    {
        this.res=res;
    }
    public void run() {
        while(true)
        {
            res.out();
        }
    }

}

对于多个生产者和消费者，为什么要定义while判断标记
原因：让被唤醒的线程再一次判断标记。

为什么要定义notifyAll
因为需要唤醒对方的线程，只有notify，容易出现只唤醒本方线程的情况，导致程序中所有线程等待。

JDK1.5中提供了多线程升级解决方案，将同步synchronized替换成现实lock操作，将object中的wait，
notify notifyAll,替换了Condition对象，该对象可以Lock锁，进行获取。
实例代码：

package Thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProduceConsumerDemo {

    public static void main(String[] args) {
        Resource r=new Resource();

        Producer pro=new Producer(r);
        Consumer con =new Consumer(r);

        Thread t1=new Thread(pro);
        Thread t2=new Thread(pro);
        Thread t3=new Thread(con);
        Thread t4=new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}
class Resource
{
    private String name;
    private int count=1;
    private boolean flag=false;

    private Lock lock =new ReentrantLock();
    private Condition condition_pro=lock.newCondition();
    private Condition condition_con=lock.newCondition();


    public  void set(String name) throws InterruptedException
    {
        lock.lock();
        try
        {
            while(flag)
                    condition_pro.await();  
            this.name=name+"--"+count++;
            System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
            flag=true;
            condition_con.signal();
        }
        finally
        {
            lock.unlock();
        }   
    }
    public  void out() throws InterruptedException
    {
        lock.lock();
        try
        {
            while(!flag)
                condition_con.await();  
        System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
        flag=false;
        condition_pro.signal();
        }
        finally
        {
            lock.unlock();//释放锁的动作一定要执行
        }

    }
}
class Producer implements Runnable
{
    private Resource res;
    Producer(Resource res)
    {
        this.res=res;
    }
    public void run() {
        while(true)
        {
            try {
                res.set("+商品+");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
class Consumer implements Runnable
{
    private Resource res;
    Consumer(Resource res)
    {
        this.res=res;
    }
    public void run() {
        while(true)
        {
            try {
                res.out();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

停止线程：
开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，也就是线程结束。
特殊情况：
当线程处于冻结状态，就不会读取到标记，那么线程就不会结束，当没有指定的方式让冻结的线程恢复到运行状态是，这时就需要对冻结进行清除，强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

Thread 类中interrupt()方法。
示例：

package Thread;

class StopThread implements Runnable
{
    private boolean flag=true;
    public synchronized void run()
    {
        while(flag)
        {
            try
            {
                wait();
            }
            catch(InterruptedException e)//抓住异常
            {
                System.out.println(Thread.currentThread().getName()+"....Exception");
                flag=false;//改变表示，让程序结束
            }


            System.out.println(Thread.currentThread().getName()+"run....");
        }
    }   
    public void changeFlag()
    {
        flag=false;
    }
}
    public class StopThreadDemo {

    public static void main(String[] args) {
        StopThread st=new StopThread();

        Thread t1=new Thread(st);
        Thread t2=new Thread(st);

        t1.start();
        t2.start();

        int num=0;
        while(true)
        {
            if(num++ == 60)
            {
                //st.changeFlag();
                t1.interrupt();//让t1继续运行
                t2.interrupt();
                break;
            }
            System.out.println( Thread.currentThread().getName()+"....."+num);
        }
        System.out.println("over");

    }

}

结果：
这里写图片描述

几个Thread类中方法：
void setDaemon(boolean on)
将该线程标记为守护线程或用户线程。

void join()
等待该线程终止。
当A线程执行到了B线程的.join()方法时，A就会等待，等B线程都执行完，A才会执行，join可以用来临时加入线程执行。

void setPriority(int newPriority)
更改线程的优先级。

加瓦安柱
关注
专栏目录
多个线程同时执行，每个线程分别打印出自己的名字
hanhy136的博客
10-29 5976
public class ThreadName extends Thread{ public void run() { System.out.println("线程:"+this.getName());//打印线程名字 } public static void main(String[] args) { // TODO Auto-generated method stub
程序员面试中遇到问题
热门推荐
09-09 5万+
面试时候经常会问的一些问题(不断补充中) 面试必备基础题目(虽然不一定常用, 仅用于面试, 面试就是把人搞的都不会然后砍价, 当然您可以讲我可以查资料完成, 但是面试的时候就是没道理的, 起码我是经常看到这些题). 如何把一段逗号分割的字符串转换成一个数组? request
黑马程序员——java基础---多线程
chao100ge的博客
07-05 524
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流----- 一、多线程概述 1、多线程 进程：是一个正在执行中的程序。每一个进程都有一个执行顺序。该顺序是一个执行路径或者称为一个控制单元。 线程：就是进程中一个负责程序执行的独立控制单元（执行路径），线程控制着进程的执行。只要进程中有一个线程在执行，进程就不会结束。 一个进程中至
黑马程序员——Java基础---多线程详解
Smile_Dark的博客
07-06 730
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------  一，多线程概念          要掌握多线程，首先你需要了解进程和线程的概念，以及两者之间的关系。          1，进程          进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系
黑马 程序员——Java基础---多线程
weixin_30319097的博客
03-24 122
黑马程序员——Java基础---多线程 ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------ 一、概述 　　对于Java而言，可以在一个程序中并发地启动多个线程，让这些线程在多处理器上同时运行。在单处理器系统中，多个线程共享CPU时间称为时间共享，而操作系统负责调度及分配资源给它们，即使是单处理器，多线程程序的运行速度也比单线程程序...
黑马程序员——Java基础---多线程同步
qq_14926317的博客
12-07 417
理解同步多线程使得多个任务可以并行执行，提高了工作效率。但同时产生了一个问题，因为线程间过快的切换，对资源的同时访问产生拥堵。就好像，大家都要进一个小巷里去，但小巷只容一人通过，结果第一个人刚要进去，第二个人也进去，两个人就挤在了一起，堵住了，出错了。实现要实现线程同步有两种方法： 关键字sunchronized 同步锁Lock 两种方法的使用方式基本相同，具体实现如下。同步关键字：synchron
黑马程序员——JAVA基础---多线程
qq_27818157的博客
07-12 480
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-一 线程概述1 进程 一个进程是一个包括有自身执行地址的程序，在多任务操作系统中，可以分配CPU时间给每一个进程。CPU在指定时间片段内执行某个进程，然后在下一个时间片段跳至另一个进程中执行，由于转换速度很快，使得每个进程像是在同时进行。 通常将正在运行的程序称为进程，现在的计算机基本上都
黑马程序员——java基础---多线程(一)
Sa916487698的博客
07-13 147
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 　　学习多线程之前的一些基本概念认知： 　　　　进程：进程是动态的、是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。 　　　　线程：线程依附于进程，可以理解为进程下的一个子执行路径，但没有进程线程无法单独执行。 　　　　两者间的...
黑马程序员——java基础---多线程(二)
Sa916487698的博客
07-15 131
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 　　 线程间的通信：简单来说，就是多个线程在操作同一资源，但操作的动作不同。 　　试想一下，对于同一个资源做不同的操作，这势必会在操作的过程中产生矛盾。为了避免这种情况的发生，就需要用的synchronized来保证，每次对共享资源的操作，只能是一条线程在进行。在用到同步的时候，...
黑马程序员——java基础-多线程
bei__kou的专栏
06-11 773
第一节：多线程的概述 一、多线程引入 1、我们在之前写的代码程序只有一个执行流程，这样的程序就是单线程程序。 2、假如一个程序有多条执行流程，那么，该程序就是多线程程序。 二、进程和线程的概念： 1、进程：应用程序在内存中运行的空间 2、线程：是进程中的一个执行单元，负责执行进程中的代码。 3、一个进程如果只有一条执行路径，则称为单线程程序。 4、一个进程如果有多条执行路径，则称为多线程程序。
黑马程序员——Java基础---Java语言基础（一）
中仔的博客
11-19 769
------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------- ------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------
黑马程序员——基础知识--多线程
a_163952的博客
10-20 304
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 多线程 多线程(multiple thread)是计算机实现多任务并行处理的一种方式。 在单线程情况下，计算机中存在一个控制权，并按照顺序依次执行指令。单线程好像是一个只有一个队长指挥的小队，整个小队同一个时间只能执行一个任务。 在多线程情境下，计算机中有多个控制权。
黑马程序员——Java基础---GUI，网络编程
u012811977的博客
08-11 705
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------  第一讲     GUI（用户图形界面） 概述 1、GUI：GraphicalUser Interface，即图形用户界面，用于计算机与用户交互的一种方式。 2、计算机与用户交互的两种方式：GUI和CLI         GUI： Graphical User Inte
黑马程序员——java基础——多线程的学习总结
黑马程序员——ItBin2015的博客
07-21 2813
android培训、java培训期待与您交流！ 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元(线程就是进程的一个执行路径)。线程在控制着进程的执行。 多线程则扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。线程(Thread )也被称作轻量级进程(Lightweight Proc
rhino grasshoper 框内物体排列（附视频）.gh
最新发布
10-18
【闭合线内物体按方向移动/排列】https://www.bilibili.com/video/BV1z1WfeSEWu?vd_source=b420114c993138474d2e93d83ead77a5
kwant-1.4.3-cp38-cp38-win_amd64.whl
10-18
kwant-1.4.3-cp38-cp38-win_amd64.whl
rhino grasshoper 景观椅（附视频）.gh
10-18
【rhino@grasshoper 曲线金属座椅景观案例（文件获取/见简介）】https://www.bilibili.com/video/BV1Dx4y147Lr?vd_source=b420114c993138474d2e93d83ead77a5
PCIe通义万问系列文档的第一部已整理完毕，含999个PCIe相关问答
10-18
《PCIe通义万问》系列文档旨在记录PCIe相关行业工程师们在PCIe协议学习、IP设计验证、产品测试及使用过程中遇到的问题、迸发的思考、进行的探讨及可能的解决方案，以期给遇到相同相似问题的同行们些许启发。文档涉及的技术方向主要为PCIe，也包含PCIe相关的CXL、UCIe及计算机体系结构相关内容。 本文档是《PCIe通义万问》系列文档之（一），含999个问题。问题内容有以下三个来源：MangoPapa（下称博主）的“PCIe每日一问一答”系列专栏；博主的博文留言及私信讨论；博主作为群主的“PCIe技术交流群”群聊内容。MangoPapa小助理、折叠、先杰、CR小队长、kangling共同完成了问答内容提取与归纳整理，噫嘘唏及慕荷负责文辞优化及编辑排版，上述人员及MangoPapa、JasonW、皮塞阿姨、席可儿参与了文档内容的审校。感谢以上人员的无私奉献。 本文档仅对讨论内容进行总结记录，不保证问题答案的正确性，部分问题只提供解决思路或讨论过程。术业有专攻，文内定有偏颇。如您发现谬误，一敬希原宥，二望乞点拨；如您持异见，欢迎来信讨论。如有需要，欢迎联系MangoPapa加入相关
Java SE6.0程序员认证：310-065试题解析
"这是一份关于SCJP（Sun ...这份PDF资料的题目涵盖了Java程序设计的基础知识，包括线程管理和异常处理，对于准备SCJP 310-065考试的考生来说，这样的练习是非常有价值的，可以帮助他们巩固理论知识，提升实战技能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值