hao947的专栏

/*需求：简单的卖票系统、 * 多个窗口买票 * * 创建线程的第二种方式：实现Runnable接口 * * 步骤： * 1、定义类实现Runnable接口 * 2、覆盖Runnable接口中的run方法 * 将线程覆盖运行的代码存放在该run方法中。 * 3、通过Thread类建立线程对象 * 4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造

/* 需求： * 银行存钱 * 有两个储户分别存300元，每次存100，存3次 * 目的：该程序是否有安全问题，如果有，如何解决？ * * 如何找问题： * 1、明确哪些是多线程运行代码 * 2、明确共享数据。 * 3、明确多线程运行代码中哪些语句是操作共享数据的。 * * * */ class Bank { private int sum; //Obj

/* 同步函数用的是哪一个锁呢？ * 函数需要被对象调用，那么函数都有一个所属对象引用，就是this * 所以同步函数使用的锁都是this * 通过该程序进行验证 * 使用两个线程来卖票 * 一个线程在同步代码块中 * 一个线程在同步函数中 * 都在执行卖票成 * */ public class ThisLockDemo { public static void main(Str

/* 如果同步函数被静态修饰后，使用的锁是什么呢？ * 通过验证，发现不在是this。因为静态方法中也不可以定义this * 静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。 * 类名.class 该对象的类型是Class * 静态的同步方法使用的锁是该方法所在类的字节码文件对象。 类名.class * */ public class ThisLockDemo {

/* 死锁 * 同步中嵌套同步。 * 死锁的概念就是：当你去买东西的时候，店小二说给钱给货，你说给货给钱，你们僵住了，就死锁了 * */ public class DeadLockDemo { public static void main(String[] args) { Object o1 = new Object(); Object o2 = new Object();

public class Deadlock{ public static void main(String[ ] args) { final Object resource1 = "resource1"; final Object resource2 = "resource2"; int a=0; Thr

// 单例设计模式 class Single1 { // 恶汉式 private static final Single1 s = new Single1(); private Single1() { } public static Single1 getInstance() { return s; } } class Single {// 懒汉式 private stat

/*线程间通讯： * 其实就是多个线程在操作同一个资源 * 但是操作的动作不同 * */ public class Communication { public static void main(String[] args) { Res r = new Res(); Input in = new Input(r); Output out = new Output(r); T

 如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，买票系统就可以这么做。  如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享：  将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个

创建线程的两种传统方式 在Thread子类覆盖的run方法中编写运行代码 涉及一个以往知识点：能否在run方法声明上抛出InterruptedException异常，以便省略run方法内部对Thread.sleep()语句的try…catch处理？ 在传递给Thread对象的Runnable对象的run方法中编写代码 总结：查看Thread类的run()方法的源代码，可以看到其实这两种方式都是在调

import java.util.*; import org.junit.Test; /*定时器的应用 Timer类 TimerTask类 */ public class TraditionalTimerTest { @Test public void TimerTest() { new Timer().schedule(new TimerTask() { @Overri

import java.io.IOException; import java.util.*; import org.junit.Test; /*定时器的应用 Timer类 TimerTask类 定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的 schedule(TimerTask task, long delay)方法，设定指定 的任务task在指定的延

public class TraditonalTreadSynchronized { public static void main(String[] args) { new TraditonalTreadSynchronized().init(); } private void init() { final Outputer outputer = new Outputer();

import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 子线程循环10次，

package com.hao947.P004.java.ThreadCallableFuture; import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; public class ThirdThread implements Callable { public static void ma

在Java中，如果需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实现，可以来进行异步计算。 Future模式可以这样来描述：我有一个任务，提交给了Future，Future替我完成这个

继承Thread类 1.子类覆盖父类中的run方式，将线程运行的代码存放在run中 2.建立子类对象的同时线程也被创建。 3.通过调用start方法开启线程。

import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; /** *//** * Callable 和 F

为了便于理解先来看看没有加同步代码块的 2 组同样功能的代码在不同状态下的执行结果，下面看第一组： package cn.sunzn.synchronize; public class SynchronizeCode { public static void main(String[] args) { new Thread() { public voi

编写多线程程序是为了实现多任务的并发执行，从而能够更好地与用户交互。一般有三种方法，Thread,Runnable,Callable. Runnable和Callable的区别是， (1)Callable规定的方法是call(),Runnable规定的方法是run(). (2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得 (3)call方法可以抛出异常，

本文是Sun官方以Blog形式发布的Java核心技术窍门(JavaCoreTechTip)中的一个。本文主要介绍了Callable及其相关接口和类的使用，篇幅不长且易于理解，故翻译在了此处，相信对于准备或刚接触java.util.concurrent的朋友会有所帮助。     自从Java平台的最开始，Runnable接口就已存在了。它允许你定义一个可由线程完成的任务。如大多数人所已知的那样，它

class MyThreadExec extends Thread { private int time; // 保存线程的休眠时间 public MyThreadExec(String name, int time) { super(name); // 设置线程名称 this.time = time;// 设置休眠的时间 } public void run() { // 覆写

/*Runnable接口实现多线程，则不像继承Tread类那样可以直接使用Thread类中的name属性， * 需要在类中单独定义一个name属性以保存名称。 * * */ class ThreadExecDemo implements Runnable { private String name; private int time; public ThreadExecDemo(S

class Zhangsan { public void say() { System.out.println("张三对李四说：“你给我画，我就把书给你”。"); } public void get() { System.out.println("张三得到画了。"); } } class Lisi { public void say() { System.out.prin

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWr

import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 子线程循环10次，

/* 多线程的运行出现了安全问题 * 问题的原因： * 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。 * 解决办法： * 对多条操作共享数据的语句，只能让一个线程都执行完成，在执行过程中，其他线程不可以参与执行。 * * 就是同步代码块 * synchronized(对象) *

/*需求：简单的卖票系统、 * 多个窗口买票 * 创建线程的第二种方式：实现Runnable接口 * 步骤： * 1、定义类实现Runnable接口 * 2、覆盖Runnable接口中的run方法 * 将线程覆盖运行的代码存放在该run方法中。 * 3、通过Thread类建立线程对象 * 4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数 *

编写多线程程序是为了实现多任务的并发执行，从而能够更好地与用户交互。一般有三种方法，Thread,Runnable,Callable. Runnable和Callable的区别是， (1)Callable规定的方法是call(),Runnable规定的方法是run(). (2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得 (3)call方法可以抛出异常，run方法

//子线程循环10次，接着主线程循环100次，接着在子线程循环10次，接着再主线程循环100次 public class SynTest { public static void main(String[] args) { final Business b = new Business(); new Thread(new Runnable() { public void run()