进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。
- 因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。
- Java 程序的进程里面至少包含两个线程，主进程也就是 main()方法线程，另外一个是垃圾回收机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。
- 由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。
Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。
Java中通过继承Thread类来创建并启动多线程的步骤如下：
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println("sub... "+i);
}
}
}
public static void main(String[] args) {
// 创建自定义的线程对象
MyThread mt = new MyThread();
// 开启线程
mt.start();
// 一个线程仅可以被启动一次
// mt.start()
// 主线程执行
for (int i = 0; i < 50; i++) {
System.out.println("main... "+i);
}
}
Thread类的方法String getName()可以获取到线程的名字。
Thread类的方法setName(String name)设置线程的名字。
通过Thread类的构造方法Thread(String name)也可以设置线程的名字。
public class Demo {
public static void main(String[] args) {
MyThread mt = new MyThread();
//设置线程名字
mt.setName("旺财");
mt.start();
}
}
class MyThread extends Thread{
public void run(){
System.out.println("线程名字:"+super.getName());
}
}
线程是有默认名字的，如果不设置，JVM会赋予线程默认名字Thread-0,Thread-1。
Demo类不是Thread的子类，因此不能使用getName()方法获取。
Thread类定义了静态方法static Thread currentThread()获取到当前正在执行的线程对象。
public static void main(String[] args){
Thread t = Thread.currentThread();
System.out.println(t.getName());
}
java.lang.Runnable接口类
步骤如下：
public class Demo {
public static void main(String[] args) {
// 创建自定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
// 创建线程对象
Thread t = new Thread(mr);
t.start();
for (int i = 0; i < 20; i++) {
System.out.println("main " + i);
}
}
}
public class MyRunnable implements Runnable{
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。
使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
public static void main(String[] args) {
// 第一种方式 实际上需要的就是Thread类的子类对象
Thread t = new Thread(){
@Override
public void run() {
System.out.println("方式一 赋值!");
}
};
t.start();
new Thread() {
@Override
public void run() {
System.out.println("方式一 直接调用!");
}
}.start();
// 第二种方式 实际上需要的就是Runnable接口的实现类对象
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("方式二 赋值!");
}
};
new Thread(r).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("方式二 直接调用!");
}
}).start();
}
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：
public static void sleep(long time) 让当前线程进入到睡眠状态，到毫秒后自动醒来继续执行
public class Test{
public static void main(String[] args){
for(int i = 1;i<=5;i++){
Thread.sleep(1000);
System.out.println(i)
}
}
}
线程的切换是由线程调度控制的,我们无法通过代码来干涉,但是我们通过提高线程的优先级最大程度的改善线程获取时间片的几率
线程的优先级被划分为10级,值分别为1-10,其中1最低,10最高.Thread提供了3个常量来表示:
public static final int MIN_PRIORITY //1 最低优先级
public static final int NORM_PRIORITY //5 默认优先级
public static final int MAX_PRIORITY //10 最大优先级
// 更改线程的优先级
public final void setPriority(int newPriority)
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println("t1: " + i);
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println("t2: " + i);
}
}
});
// 设置优先级
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
让当前线程等待,调用方法的线程进行插队先执行,执行完毕后,在让当前线程执行.对其他线程没有任何影响.
注意 此处的当前线程不是调用方法的线程 而是Thread.currentThread().
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println("t1: " + i);
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println("t2: " + i);
}
}
});
t1.start();
// t1.join();
/* t1在此处插队时
此时 Thread.currentThread() 为 main 线程, 所以 main 线程等待, t1 线程插队
由于main 线程等待 t2线程还未开启, 因此t1执行完毕, main和t2抢
*/
t2.start();
t1.join();
/* t1在此处插队时
此时 Thread.currentThread() 依然为 main 线程, 所以 main 线程等待, t1 线程插队
而在这之前 t2 线程已经开启, 因此会出现两种情况:
1. t2 先执行完 t1 执行完之后 主线程执行
2. t1 先执行完 t2 和 主线程抢
*/
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
三个线程同时开启 保证线程一之后执行线程二 再之后执行线程三
class JoinMethodTest {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println("t1: " + i);
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 50; i++) {
System.out.println("t2: " + i);
}
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
try {
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 50; i++) {
System.out.println("t3: " + i);
}
}
});
t1.start();
t2.start();
t3.start();
}
}
public final void stop() 直接中断线程 此方法已过时 不安全
public boolean isInterrupted() 获取线程是否中断的状态 如果中断返回true 没中断返回false
public void interrupt() 中断线程 此时调用interrupted方法 会返回true
代码演示:
public class Test02 {
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i <1000000 ; i++) {
System.out.println(i);
//是否有人要中断线程 如果有返回true 如果没有返回false
//让线程中断更为平滑 可以使用代码来控制中断
boolean b = Thread.currentThread().isInterrupted();
if(b){
break;
}
}
}
});
t1.start();
try {
Thread.sleep(2000);
// t1.stop(); //方法已经过时 不安全
t1.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
java分为两种线程:用户线程和守护线程
/*
用户线程
我们正常写的代码都是用户线程
守护线程
用户线程存在 守护线程可以执行 用户线程执行完成 守护线程即使没有执行完 jvm也会退出
守护线程和用户线程没有本质的区别，唯一不同之处就在于虚拟机的退出:
如果用户线程已经全部退出运行了,只剩下守护线程存在,虚拟机会直接退出.但是只要有用户线程运行,虚拟机就不会退出.
设置守护线程:
public final void setDaemon(boolean on) on的值为true将线程设置为守护线程,需要在开启线程之前设置
*/
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1: " + i);
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t2: " + i);
}
}
});
/*
由于t2每次休眠50ms, 而t1休眠200ms, 所以t2先执行完
而t1并不是守护线程, 所以t2执行完后, t1继续执行
*/
// t1.start();
// t2.start();
//将t1设置为守护线程, t2执行完后, t1将不再执行, jvm直接退出
t1.setDaemon(true);
t1.start();
t2.start();
}
多条线程操作同一资源时 可能出现数据错误 此时线程是不安全的
public class Demo {
public static void main(String[] args) {
SellTickets st = new SellTickets();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
Thread t3 = new Thread(st);
t1.start();
t2.start();
t3.start();
}
}
class SellTickets implements Runnable {
private int i = 20;
public void run() {
while (true) {
if (i > 0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 卖票 " + i--);
}
}
}
}
/*
Thread-2 卖票 19
Thread-0 卖票 20
Thread-1 卖票 18
Thread-1 卖票 17
Thread-2 卖票 15
Thread-0 卖票 16
Thread-2 卖票 14
Thread-0 卖票 13
Thread-1 卖票 12
Thread-1 卖票 10
Thread-0 卖票 9
Thread-2 卖票 11
Thread-2 卖票 8
Thread-0 卖票 8
Thread-1 卖票 6
Thread-0 卖票 5
Thread-2 卖票 4
Thread-1 卖票 3
Thread-2 卖票 2
Thread-1 卖票 1
Thread-0 卖票 0
Thread-2 卖票 -1
*/
发现程序出现了两个问题：
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。
根据案例简述：
窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。
也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。
为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。
同步代码块：线程操作的共享数据进行同步。synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
// 格式
synchronized(同步锁){
需要同步操作的代码
}
同步锁:
同步锁又称为对象监视器。同步锁只是一个概念,可以想象为在对象上标记了一个锁.
注意：在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。
使用同步代码块解决代码：
public class Ticket implements Runnable{
private int ticket = 100;
private Object lock = new Object();
/*
* 执行卖票操作
*/
@Override
public void run() {
//每个窗口卖票的操作
//窗口 永远开启
while(true){
synchronized (lock) {
if(ticket>0){//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name+"正在卖:"+ticket--);
}
}
}
}
}
注意：线程运行至同步代码块的时候，需要判断锁，获取锁，出去同步代码块后要释放锁，增加了很多操作，因此线程安全，程序的运行速度慢！
同步方法:当一个方法中的所有代码，全部是线程操作的共享数据的时候，可以将整个方法进行同步。使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
// 格式
public synchronized void method(){
// 可能会产生线程安全问题的代码
}
使用同步方法代码如下：
public class Ticket implements Runnable{
private int ticket = 100;
/*
* 执行卖票操作
*/
@Override
public void run() {
//每个窗口卖票的操作
//窗口 永远开启
while(true){
sellTicket();
}
}
/*
* 锁对象 是 谁调用这个方法 就是谁
* 隐含 锁对象 就是 this
*
*/
public synchronized void sellTicket(){
if(ticket>0){//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name+"正在卖:"+ticket--);
}
}
}
同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
public void lock() :加锁。public void unlock():释放锁。使用如下：
public class Ticket implements Runnable{
private int ticket = 100;
Lock lock = new ReentrantLock();
/*
* 执行卖票操作
*/
@Override
public void run() {
//每个窗口卖票的操作
//窗口 永远开启
while(true){
lock.lock();
if(ticket>0){//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name+"正在卖:"+ticket--);
}
lock.unlock();
}
}
}
这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析。
| 线程状态 | 导致状态发生条件 |
|---|---|
| NEW(新建) | 线程刚被创建，但是并未启动。还没调用start方法。 |
| Runnable(可运行) | 线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。 |
| Blocked(锁阻塞) | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
| Waiting(无限等待) | 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。 |
| Timed Waiting(计时等待) | 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。 |
| Teminated(被终止) | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |
Object类的方法
void wait()
// 在其他线程对用此对象的notify()方法或notifyAll方法前, 导致当前线程等待
void wait(long time)
// 当前线程等待 time 毫秒
void notify()
// 唤醒在此对象监视器上等待的单个线程
void notifyAll()
// 唤醒在此对象监视器上等待的所有线程
public class RelatedInObject {
public static void main(String[] args) throws InterruptedException {
Object o = new Object();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (o) {
System.out.println("开始等待");
try {
o.wait();
// 等待3000毫秒后
// o.wait(3000);
System.out.println("已经被唤醒");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("end");
}
}).start();
Thread.sleep(5000);
synchronized (o) {
System.out.println("开始唤醒");
o.notify();
}
}
}
我真的很习惯使用Ruby编写以下代码:my_hash={}my_hash['test']=1Java中对应的数据结构是什么？ 最佳答案 HashMapmap=newHashMap();map.put("test",1);我假设？ 关于java-等价于Java中的RubyHash，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.com/questions/22737685/
我收到这个错误:RuntimeError(自动加载常量Apps时检测到循环依赖当我使用多线程时。下面是我的代码。为什么会这样？我尝试多线程的原因是因为我正在编写一个HTML抓取应用程序。对Nokogiri::HTML(open())的调用是一个同步阻塞调用，需要1秒才能返回，我有100,000多个页面要访问，所以我试图运行多个线程来解决这个问题。有更好的方法吗？classToolsController0)app.website=array.join(',')putsapp.websiteelseapp.website="NONE"endapp.saveapps=Apps.order("
我正在尝试使用boilerpipe来自JRuby。我看过guide从JRuby调用Java，并成功地将它与另一个Java包一起使用，但无法弄清楚为什么同样的东西不能用于boilerpipe。我正在尝试基本上从JRuby中执行与此Java等效的操作:URLurl=newURL("http://www.example.com/some-location/index.html");Stringtext=ArticleExtractor.INSTANCE.getText(url);在JRuby中试过这个:require'java'url=java.net.URL.new("http://www
我只想对我一直在思考的这个问题有其他意见，例如我有classuser_controller和classuserclassUserattr_accessor:name,:usernameendclassUserController//dosomethingaboutanythingaboutusersend问题是我的User类中是否应该有逻辑user=User.newuser.do_something(user1)oritshouldbeuser_controller=UserController.newuser_controller.do_something(user1,user2)我
什么是ruby的rack或python的Java的wsgi？还有一个路由库。 最佳答案 来自Python标准PEP333:Bycontrast,althoughJavahasjustasmanywebapplicationframeworksavailable,Java's"servlet"APImakesitpossibleforapplicationswrittenwithanyJavawebapplicationframeworktoruninanywebserverthatsupportstheservletAPI.ht
这篇文章是继上一篇文章“Observability：从零开始创建Java微服务并监控它（一）”的续篇。在上一篇文章中，我们讲述了如何创建一个Javaweb应用，并使用Filebeat来收集应用所生成的日志。在今天的文章中，我来详述如何收集应用的指标，使用APM来监控应用并监督web服务的在线情况。源码可以在地址 https://github.com/liu-xiao-guo/java_observability 进行下载。摄入指标指标被视为可以随时更改的时间点值。当前请求的数量可以改变任何毫秒。你可能有1000个请求的峰值，然后一切都回到一个请求。这也意味着这些指标可能不准确，你还想提取最小/
HashMap中为什么引入红黑树，而不是AVL树呢1.概述开始学习这个知识点之前我们需要知道，在JDK1.8以及之前，针对HashMap有什么不同。JDK1.7的时候，HashMap的底层实现是数组+链表JDK1.8的时候，HashMap的底层实现是数组+链表+红黑树我们要思考一个问题，为什么要从链表转为红黑树呢。首先先让我们了解下链表有什么不好？？？2.链表上述的截图其实就是链表的结构，我们来看下链表的增删改查的时间复杂度增：因为链表不是线性结构，所以每次添加的时候，只需要移动一个节点，所以可以理解为复杂度是N(1)删：算法时间复杂度跟增保持一致查：既然是非线性结构，所以查询某一个节点的时候
遍历文件夹我们通常是使用递归进行操作，这种方式比较简单，也比较容易理解。本文为大家介绍另一种不使用递归的方式，由于没有使用递归，只用到了循环和集合，所以效率更高一些！一、使用递归遍历文件夹整体思路1、使用File封装初始目录，2、打印这个目录3、获取这个目录下所有的子文件和子目录的数组。4、遍历这个数组，取出每个File对象4-1、如果File是否是一个文件，打印4-2、否则就是一个目录，递归调用代码实现publicclassSearchFile{publicstaticvoidmain(String[]args){//初始目录Filedir=newFile("d:/Dev");Datebeg
我正在尝试使用ruby编写一个双线程客户端，一个线程从套接字读取数据并将其打印出来，另一个线程读取本地数据并将其发送到远程服务器。我发现的问题是Ruby似乎无法捕获线程内的错误，这是一个示例:#!/usr/bin/rubyThread.new{loop{$stdout.puts"hi"abc.putsefsleep1}}loop{sleep1}显然，如果我在线程外键入abc.putsef，代码将永远不会运行，因为Ruby将报告“undefinedvariableabc”。但是，如果它在一个线程内，则没有错误报告。我的问题是，如何让Ruby捕获这样的错误？或者至少，报告线程中的错误？
我基本上来自Java背景并且努力理解Ruby中的模运算。(5%3)(-5%3)(5%-3)(-5%-3)Java中的上述操作产生，2个-22个-2但在Ruby中，相同的表达式会产生21个-1-2.Ruby在逻辑上有多擅长这个？模块操作在Ruby中是如何实现的？如果将同一个操作定义为一个web服务，两个服务如何匹配逻辑。 最佳答案 在Java中，模运算的结果与被除数的符号相同。在Ruby中，它与除数的符号相同。remainder()在Ruby中与被除数的符号相同。您可能还想引用modulooperation.