java多线程学习 代码笔记

最新推荐文章于 2024-07-09 16:17:35 发布
最新推荐文章于 2024-07-09 16:17:35 发布
阅读量200 收藏 1
点赞数
分类专栏： java基础 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43597773/article/details/114792768
版权

继承Thead创建线程

public class Threadtest extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("A" + i);
        }
    }
    public static void main(String[] args) {
        Threadtest threadtest = new Threadtest();
        threadtest.run();
        for (int i = 0; i < 500; i++) {
            System.out.println("B" + i);
        }

    }
}

继承Runable 创建线程

public class Threadtest2 implements Runnable{
        //多个线程同时操作一个对象
    private static int ticketNums = 10;
    @Override
    public void run() {
           if(Thread.currentThread().getName().equals("A")){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
           while (true) {
               if (ticketNums < 0) break;
               try {
                   Thread.sleep(200);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums + "票");
               ticketNums--;
           }

    }
    public static void main(String[] args) {
        Threadtest2 test = new Threadtest2();
        new Thread(test,"A").start();
        new Thread(test,"B").start();//使用了静态代理 代理了这个类的线程
        new Thread(test,"C").start();
    }
}

lamda表达式的演变过程



// 推到lamda表达式
// 函数式接口 就是一个接口只有一个方法的那种
public class Lamda {
    //静态内部类
    static   class Like2 implements Like{

        @Override
        public void lamda() {
            System.out.println("Like");
        }
    }
    public static void main(String[] args) {
        Like like = new Like1();
        like.lamda();
        Like like1 = new Like2();
        like1.lamda();
        // 4.局部内部类
        class Like3 implements Like{

            @Override
            public void lamda() {
                System.out.println("Like");
            }
        }
        Like like2 = new Like3();
        like2.lamda();
        // 5.局部内部类
        like = new Like() {
            @Override
            public void lamda() {
                System.out.println("leike1");
            }
        };
        like.lamda();
        //6. 用lamba简化
        Like like6 = ()->{
            System.out.println("like222");
        };
        like6.lamda();
    }

}
// 1.定义一个函数式接口
interface  Like{
    void lamda();
}

//2.实现类
class Like1 implements Like{

    @Override
    public void lamda() {
        System.out.println("Like");
    }
}

线程的5种状态

在这里插入图片描述

线程方法 在这里插入图片描述

停止线程 在这里插入图片描述

标志位停止线程的代码
public class stop implements Runnable{
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0 ;
        while(flag){
            System.out.println(":"+i++);
        }
    }

    public void stop(){
        flag = false;
    }

    public static void main(String[] args) throws InterruptedException {
        stop stop = new stop();
        new Thread(stop).start();
        Thread.sleep(20);
        stop.stop();
    }
}

线程休眠

在这里插入图片描述

public class Threadtest2 implements Runnable{
        //多个线程同时操作一个对象
    // 模拟网络延时，放大进程间的问题
    private static int ticketNums = 10;
    @Override
    public void run() {
           if(Thread.currentThread().getName().equals("A")){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
           while (true) {
               if (ticketNums < 0) break;
               try {
                   Thread.sleep(200);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums + "票");
               ticketNums--;
           }

    }
    public static void main(String[] args) {
        Threadtest2 test = new Threadtest2();
        new Thread(test,"A").start();
        new Thread(test,"B").start();
        new Thread(test,"C").start();
    }
}

利用线程休眠看系统时间

import java.text.SimpleDateFormat;
import java.util.Date;

public class Threadtest1 {

    public static void main(String[] args)  {
        Date time = new Date(System.currentTimeMillis());//获取当前系统时间
        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("hh:mm:ss").format(time));
                time = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程礼让 yield

在这里插入图片描述

public class testyield  {
    // 礼让不一定成功 看cup心情


    public static void main(String[] args) {
//        MYyeild mYyeild = new MYyeild();
//        new Thread(mYyeild,"a").start();
//        new Thread(mYyeild,"b").start();
        new Thread(()->{ //lamda表达式
            System.out.println("start1");
            Thread.yield();
            System.out.println("end1");
        }).start();
        new Thread(()->{
            System.out.println("start2");
//            Thread.yield();
            System.out.println("end2");
        }).start();

    }
}
//class MYyeild implements Runnable{
//    @Override
//    public void run() {
//        System.out.println("start");
//        Thread.yield();
//        System.out.println("end");
//    }
//}

join

  • join 合并线程 ，等这个线程执行完成后，在执行其他线程，其他线程阻塞
  • 可以理解为插队
public class join implements Runnable{
   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           System.out.println(i);
       }
   }
   public static void main(String[] args) throws InterruptedException {
       join join = new join();
       Thread thread = new Thread(join);
       for (int i = 0; i < 500; i++) {
           if(i==20){
               thread.start();
               thread.join();
           }
           System.out.println("main"+i);
       }
   }
}

线程状态观测

在这里插入图片描述

观测线程状态
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("");
        });
        Thread.State state = thread.getState();
        System.out.println(state);
        thread.start();
        state = thread.getState();
        System.out.println(state);//Run

        while(state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
        thread.start();//（会报错）线程死亡后就不能再次启动了
    }
}
线程的优先级
代码
public class TestPriority{

    public static void main(String[] args) {
        System.out.println("main"+Thread.currentThread().getPriority());
        Mypriorty mypriorty = new Mypriorty();
        Thread t1 = new Thread(mypriorty);
        Thread t2 = new Thread(mypriorty);
        Thread t3 = new Thread(mypriorty);
        Thread t4 = new Thread(mypriorty);
        t1.start();


        t2.setPriority(1);
        t2.start();


        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//并不是设置的优先级高的就会先启动
        t4.start();
        
    }
}
class Mypriorty implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"->"+Thread.currentThread().getPriority());
    }
}

线程的分类

  • 守护线程（gc垃圾回收）
  • 用户线程（main方法）
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕（就是用户线程结束 虚拟机就会停止）
public class Testdaemon {

  public static void main(String[] args) {
      God god = new God();
      he he = new he();
      Thread thread = new Thread(god);
      thread.setDaemon(true);// 默认值式false 表示用户线程，正常的线程都是用户线程
      thread.start();// 上帝守护的线
      new Thread(he).start();
  }
}
class God implements Runnable{

  @Override
  public void run() {
      while (true){
          System.out.println("上帝");
      }
  }
}

class he implements Runnable{
      @Override
      public void run() {
          for (int i = 0; i < 36500; i++) {
              System.out.println("活着");
          }
          System.out.println("走了");
      }
  }
}

线程同步

  • 线程不安全的例子
public class UnsafeuyTicket {

    public static void main(String[] args) {
        Buyticket buyticket = new Buyticket();
        new Thread(buyticket,"我").start();
        new Thread(buyticket,"你").start();
        new Thread(buyticket,"黄牛").start();
    }
}

class Buyticket implements Runnable{

    private  int ticketnums = 10;
    boolean flag = true;//外部停止方式
    @Override
    public void run() {
        while (flag){
            try {
                Thread.sleep(100);
                buy();
                ticketnums--;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
    private void buy(){
        if(ticketnums<=0) {
            flag = false;
            return  ;
        }
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketnums);
    }

}
  • Arrylist线程不安全的例子
import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
  public static void main(String[] args) throws InterruptedException {
      List<String> list = new ArrayList<>();
      for (int i = 0; i < 10000; i++) {
          new Thread(()->{
              list.add(Thread.currentThread().getName());//出现问题时 两个线程同时存储一个下标的值就会List就会被修改.
          }).start();
      }
      Thread.sleep(1000);
      System.out.println(list.size());
  }

}

同步方法和同代码块

  • sychronized方法
public class UnsafeuyTicket {

    public static void main(String[] args) {
        Buyticket buyticket = new Buyticket();
        new Thread(buyticket,"我").start();
        new Thread(buyticket,"你").start();
        new Thread(buyticket,"黄牛").start();
    }
}

class Buyticket implements Runnable{

    private  int ticketnums = 10;
    boolean flag = true;//外部停止方式
    @Override
    public void run() {
        while (flag){
            try {
                Thread.sleep(100);
                buy();
                ticketnums--;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
    private synchronized void buy(){
        if(ticketnums<=0) {
            flag = false;
            return  ;
        }
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketnums);
    }

}
  • 解决arrylist线程不安全的例子
import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
   public static void main(String[] args) throws InterruptedException {
       List<String> list = new ArrayList<>();
       for (int i = 0; i < 10000; i++) {
           new Thread(()->{
               synchronized (list){ //同步代码块  锁的是发生变化的对象
                   list.add(Thread.currentThread().getName());//出现问题时 两个线程同时存储一个下标的值就会List就会被修改.
               }

           }).start();
       }
       Thread.sleep(1000);
       System.out.println(list.size());
   }

}

死锁产生的必要条件

  • 互斥：每个资源只能被一个进程使用
  • 占有和等待：已经得到了资源的进程可以再申请新的资源并且不释放以获得的资源
  • 不可抢占：已经分配给一个进程的资源不能被抢占，只能被显示的释放
  • 环路等待：两个或以上的进程组成一条环路，每个进程都在等待下一个进程占有的资源
  • 有一条不满足就不会发生死锁

死锁产生代码案例

package lock;
//死锁，两个或以上线程占用对方需要的资源，互不释放 形成思索
public class Deadlock {
    public static void main(String[] args) {
        new Thread(new boy(0,"小明"),"a").start();
        new Thread(new boy(1,"小红"),"b").start();
    }
}
class apple{

}
class banana{

}
class boy implements Runnable{

    private static apple apple = new apple();
    private static banana banana = new banana();
    private int choice;
    private String name;
    public boy(int choice,String name){
        this.choice = choice;
        this.name = name;
    }
    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void  makeup() throws InterruptedException {
        if(choice==0){
            synchronized (apple){//锁住苹果这个资源 再去拿香蕉
                System.out.println(this.name+"拿到了苹果");
                Thread.sleep(2000);//添加睡眠是怕同时拿到了 两把锁 影响实践的结果
                synchronized (banana){ //将这个锁拿到外面就可以解决  让他让出苹果 在去拿香蕉 就不会影响别人拿苹果
                    System.out.println(this.name+"拿到香蕉");
                }
            }
        }else{
            synchronized (banana) {//锁住香蕉这个资源 再去拿苹果
                System.out.println(this.name + "拿到了香蕉");
                Thread.sleep(2000);//添加睡眠是怕同时拿到了 两把锁 影响实践的结果
                synchronized (apple) {
                    System.out.println(this.name + "拿到苹果");
                }
            }
        }
    }
}

将同步块移出就可以得到 解决争夺资源，却不释放资源

在这里插入图片描述

lock与synchronized 的对比在这里插入图片描述

lock代码案例
package lock;

import java.util.concurrent.locks.ReentrantLock;

public class Testlock {

    public static void main(String[] args) {
        Testlock2 testlock2 = new Testlock2();
        new Thread(testlock2,"a").start();

        new Thread(testlock2,"b").start();
        new Thread(testlock2,"c").start();

    }
}

class Testlock2 implements Runnable{

    private  static int ticketmuns = 10;

    private  final ReentrantLock lock = new ReentrantLock();//可重入锁


    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while(true){
            try{
                lock.lock();//加锁
                if(ticketmuns > 0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+" :"+ticketmuns--);
                }else{
                    break;
                }
            }finally {
                lock.unlock();//解锁
            }

        }
    }
}

线程协作 通信

  • 生产者消费者(管程法)
package lock;

//测试，生产者消费者模型 --> 利用缓冲区解决 管程法
// 生产者，消费者，产品，缓冲区

public class TestPC {

   public static void main(String[] args) {
       SynContainer container = new SynContainer();
       new Productor(container).start();
       new Consumer(container).start();
   }
}

// 生产者
class Productor extends Thread{
   SynContainer container;
   public Productor(SynContainer container){
       this.container = container;
   }
   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           try {
               container.push(new Chicken(i));
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("生产了第"+i+"产品");
       }
   }
}


// 消费者
class  Consumer extends Thread{
   SynContainer container;
   public Consumer(SynContainer container){
       this.container = container;
   }

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           Chicken chicken = container.pop();
           System.out.println("消费了第"+i+"产品");
       }
   }
}
//产品
class Chicken{
   int id ;//产品编号
   public Chicken(int id){
       this.id = id;
   }
}
// 缓冲区
class SynContainer{
   Chicken[] chickens = new Chicken[10];
   private static int count= 0;
   public  synchronized int getCount(){
       return count;
   }
   public synchronized  void push(Chicken chicken) throws InterruptedException {
       //如果容器满了 就需要等待消费者消费
       if(count == chickens.length){
       this.wait();
       }
       //如果没有满，我们就需要push产品
       chickens[count] = chicken;
       count++;
       this.notify();
   }
   // 消费者消费产品
   public synchronized Chicken pop(){
       Chicken chicken = null;
       //判断缓存池中还有没有产品
       if( count == 0){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }else{
           //如果可以消费
           count -- ;
           chicken  = chickens[count];
       }
       this.notify();
       //吃完了，通知生产者 生产
       return chicken;
   }
}
信号灯法
package lock;

import java.util.TreeMap;

public class TestPC2 {
   public static void main(String[] args) {
       TV tv = new TV();
       new Player(tv).start();
       new Watcher(tv).start();
   }
}
class Player extends Thread{
   TV tv;
   public Player(TV tv){
       this.tv = tv;
   }

   @Override
   public void run() {
       for (int i = 0; i < 20; i++) {
           if(i%2==0){
               tv.play("猫和老鼠");
           }else{
               tv.play("奥特曼");
           }
       }
   }
}
class Watcher extends Thread{
   TV tv;
   public Watcher(TV tv){
       this.tv = tv;
   }

   @Override
   public void run() {
       for (int i = 0; i < 20; i++) {
           tv.watch();
       }
   }
}
//产品
class TV {
       //生产者表演，T
       //消费者观看，F
   String voice; //表演的节目
   boolean flag = true;
   //表演
   public synchronized  void play(String voice){
       if(!flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("演员表演了"+voice);
       //通知观众观看
       this.voice = voice;
       this.flag = !this.flag;
       this.notify();
   }

   //观看
   public synchronized void watch(){
       if(flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("观众观看了");
       this.flag = !this.flag;
       this.notify();
   }
}

线程池的使用

在这里插入图片描述

实现代码如下
package lock;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//测试线程池
public class Testpool {


    public static void main(String[] args) {
        //创建服务，创建线程池
        //.newFixedThreadPool 参数为 线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        // 执行
        service.execute(new Mytest());
        service.execute(new Mytest());
        service.execute(new Mytest());
        service.execute(new Mytest());
        // 关闭连接
        service.shutdown();
    }
}

class Mytest implements Runnable{
    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName());
    }
}

线程创建的几种方式

  • Callable和Runable 的区别 前者有返回值 后者没有
package Test;

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

public class Testnew {
   public static void main(String[] args) {
       new Myclass().start();
       new Thread(new Myclass1()).start();
       FutureTask<Integer> futureTask = new FutureTask<Integer>(new Myclass2());
       new Thread(futureTask).start();

       try {
           Integer integer = futureTask.get();
           System.out.println("Callable的返回值"+integer);
       } catch (InterruptedException e) {
           e.printStackTrace();
       } catch (ExecutionException e) {
           e.printStackTrace();
       }
   }
}
class Myclass extends Thread{
   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
       System.out.println("Myclass");
   }
}
class Myclass1 implements  Runnable{

   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
       System.out.println("Myclass1");
   }
}
class  Myclass2 implements Callable<Integer>{

   @Override
   public Integer call() throws Exception {

       System.out.println(Thread.currentThread().getName());
       System.out.println("Myclass2");
       return 100;
   }
}
qq_43597773
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
java多线程学习笔记
qq_69080551的博客
07-15 182
synchronized方法控制对"对象"的访问，每个对象对应一把锁，每个synchronized方法都必须获得该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占这锁（可以想象每个厕所都有门，门上有锁），直到后面的方法返回才释放锁，后面的被阻塞的线程才能获得这个锁，继续执行。多个线程各自占有一些共享的资源，并且互相等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情形，某一个同步代码块同时拥有“两个以上的对象的锁”，就可能发生死锁。...
Java多线程学习笔记
Marshal丶张的博客
06-06 149
一、多线程是什么？ 介绍多线程之前要介绍线程，介绍线程则离不开进程。 进程：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元，一个进程一直运行，直到所有的非守护线程都结束运行后才能jie。 线程：就是进程中的一个独立控制单元，线程在控制这进程的执行。一个进程中至少有一个线程，线程不能独立存在，必须是进程的一部分。 多线程：一个进程中有多个线程...
Java自学笔记：继承Thread类实现多线程
weixin_48883622的博客
08-31 272
TestThread.java： //继承Thread类的方法实现多线程 public class TestThread extends Thread{ @Override public void run() { System.out.println("多线程的运行代码"); for (int i = 0 ; i<4;i++){ System.out.println("这是多线程的逻辑代码："+i); }...
java基础-5 多线程
QYmufeng的博客
11-01 176
多线程 目录 多线程 进程和线程 多线程实现 设置获取线程名称 线程调度（设置线程优先级） 进程和线程 进程：是正在运行的程序是系统进行资源分配和调用的独立单位每一个进程都有它自己的内存空间和系统资源 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 多线程实...
ThreadLocal
qq_40315429的博客
02-15 180
ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问(通过get或set方法访问)时能保证各个线程里的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程的上下文。 可以总结为一句话：ThreadLocal的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。 举个例子，我出门需要先坐公交再做地铁，这里的坐公交和坐地铁就好比是同一个线程
java编程之线程,继承Thread类,匿名内部类的写法
小灰灰的博客
12-25 1028
package ThreadTest; //java编程之线程,继承Thread类,匿名内部类的写法 public class Test3 { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println("当前线程的名字："+Thr
Java多线程-继承Thread类，示例
DataB的博客
07-05 2478
继承Thread类，调用start方法启动线程。 示例， public class ThreadTest extends Thread { public ThreadTest(String name){ super(name); } @Override public void run() { for (int i = 0; i<5 ; i++){ System.out.println("Thread-".
java多线程代码笔记
06-07
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高系统效率和资源利用率。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 首先，让我们从创建线程开始。当...
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
java-多线程学习代码.zip
10-19
多线程的学习的笔记 Thread1:继承Thread类 * Thread2:继承Runnable接口 * * ThreadMethod：一些Thread常见方法 * ThreadTestDome1 练习：创建两个线程 其中一个线程遍历100以内的偶数 另一个遍历一百内奇数 ...
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java创建线程有四个方法： 1.继承Thread类 2.实现Runnable接口 3.实现Callable接口 4.创建线程池
编码人生
10-27 977
分别用四种创建线程的方式计算1到100之间偶数的和 1.继承Thread类 public class ThreadTest { public static void main(String[] args) { sumTest sumTest= new sumTest(); sumTest.run(); } } class sumTest extends Thread{ @Override public void run() {
关于Java的线程同步问题
YTTCJJ的专栏
11-12 569
转载自：http://jamesby.iteye.com/blog/41692 第一种情况，synchronized无效  package com.test; public class ThreadTest extends Thread {       private int threadNo;       public ThreadTest(int threadNo) {
Java多线程编程
五谷杂粮
09-25 96
编写具有多线程能力的程序经常会用到的方法有： run(),start(),wait(),notify(),notifyAll(),sleep(),yield(),join() 还有一个重要的关键字：synchronized 本文将对以上内容进行讲解。 一：run()和start() 示例1： public class ThreadTest extends Thread { public void...
实现线程的两种方式——继承Thread类
qq_41978199的博客
06-08 811
package thread;/* * 线程简介 * 实现线程的两种方式 * 在Java中提供两种方式实现线程 * 继承java.lang.Thread类与实现java.lang.Runnable接口 * 1.继承Thread类 */public class ThreadTest extends Thread{    private int count=10;    public void run...
Java 继承 Thread 类
asing1elife's blog
10-01 167
如果只是启动一个线程，则可通过继承 Thread 类来实现 但一般推荐使用 Runnable - Java 实现 Runnable 接口 Thread 类实际上也是实现了 Runnable 接口 更多精彩 更多技术博客，请移步 asing1elife’s blog 注意 程序运行时，Java 虚拟机启动一个进程，主线程在 main() 调用时被创建 在 main() 中调用 Thread...
java练习_Java基础笔试练习（十五）
weixin_39611666的博客
11-23 957
Java基础笔试练习(十五)1. 有以下代码片段,请问输出的结果是()?String str1="hello";String str2="he"+ new String("llo");System.out.println(str1==str2);A.trueB.都不对C.nullD.false答案：D解析：String str1="hello"; 这样创建字符串是存在于常量池中String str...
java Object 转 Integer
最新发布
servepeople的博客
07-09 233
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java中的多线程笔记
07-08
Java中的多线程笔记： 在Java程序中，线程的状态有以下几种：New、Runnable、Blocked、Waiting、Timed Waiting和Terminated。线程对象只能调用一次start()方法启动新线程，并在新线程中执行run()方法。一旦run()...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值