java线程学习总结
java线程学习总结1(java thread培训总结1)
1．线程中一些基本术语和概念 (2)
1.1线程的几个状态 (2)
1.2 Daemon线程 (2)
1.3锁的定义 (2)
1.4死锁 (2)
1.5.Java对象关于锁的几个方法 (3)
1.6锁对象(实例方法的锁) (3)
1.7类锁 (4)
1.8.线程安全方法与线程不安全方法 (4)
1.9类锁和实例锁混合使用 (4)
1.10锁的粒度问题 (4)
1.11.读写锁 (5)
1.12 volatile (5)
2．线程之间的通讯 (5)
2.1屏障 (6)
2.2.锁工具类 (6)
2.3.条件变量 (6)
3. Java线程调度 (7)
3.1 Java优先级 (7)
3.2. 绿色线程 (7)
3.3 本地线程 (7)
3.4 Windows本地线程 (7)
3.5线程优先级倒置与继承 (8)
3.6循环调度 (8)
4.线程池 (8)
5工作队列 (9)
6.参考资料 (10)
1．线程中一些基本术语和概念
1.1线程的几个状态
初始化状态
就绪状态
运行状态
阻塞状态
终止状态
1.2 Daemon线程
Daemon线程区别一般线程之处是：主程序一旦结束，Daemon线程就会结束。
1.3锁的定义
为了协调多个并发运行的线程使用共享资源才引入了锁的概念。
1.4死锁
任何多线程应用程序都有死锁风险。当一组线程中的每一个都在等待一个只
有该组中另一个线程才能引起的事件时，我们就说这组线程死锁了。换一个说法就是一组线程中的每一个成员都在等待别的成员占有的资源时候，就可以说这组线程进入了死锁。死锁的最简单情形是：线程 A 持有对象X 的独占锁，并且在等待对象Y 的锁，而线程 B 持有对象Y 的独占锁，却在等待对象X 的锁。除非有某种方法来打破对锁的等待（Java 锁定不支持这种方法），否则死锁的线程将永远等下去。
1.5.Java对象关于锁的几个方法
1.5.1 wait方法
wait方法是java根对象Object含有的方法，表示等待获取某个锁。在wait 方法进入前，会释放相应的锁，在wait方法返回时，会再次获得某个锁。
如果wait()方法不带有参数，那只有当持有该对象锁的其他线程调用了notify 或者notifyAll方法，才有可能再次获得该对象的锁。
如果wait()方法带有参数，比如：wait(10)，那当持有该对象锁的其他线程调用了notify或者notifyAll方法，或者指定时间已经过去了，才有可能再次获得该对象的锁。
参考thread.lock.SleepAndWait
1.5.2 notify/notifyAll方法
这里我就不再说明了。哈哈，偷点懒。
1.5.3 yield方法
yield()会自动放弃CPU，有时比sleep更能提升性能。
1.6锁对象(实例方法的锁)
在同步代码块中使用锁的时候，担当锁的对象可以是这个代码所在对象本身或者一个单独的对象担任，但是一定要确保锁对象不能为空。如果对一个null 对象加锁，会产生异常的。原则上不要选择一个可能在锁的作用域中会改变值的实例变量作为锁对象。
锁对象,一种是对象自己担任，一种是定义一个普通的对象作为private property来担任，另外一种是建立一个新的类，然后用该类的实例来担任。
参考 :
https://www.360docs.net/doc/3614600179.html,eSelfAsLock，使用对象自己做锁对象
https://www.360docs.net/doc/3614600179.html,eObjAsLock 使用一个实例对象作锁对象
https://www.360docs.net/doc/3614600179.html,eAFinalObjAsLock使用常量对象作为一个锁对象
1.7类锁
实例方法存在同步的问题，同样，类方法也存在需要同步的情形。一般类方法的类锁是一个static object来担任的。当然也可以采用类本身的类对象来作为类锁。
一个类的实例方法可以获得该类实例锁，还可以尝试去访问类方法，包含类同步方法，去获得类锁。
一个类的类方法，可以尝试获得类锁，但是不可以尝试直接获得实例锁。需要先生成一个实例，然后在申请获得这个实例的实例锁。
参考
https://www.360docs.net/doc/3614600179.html,eStaticObjAsStaticLock 使用类的属性对象作为类锁。
https://www.360docs.net/doc/3614600179.html,eClassAsStaticLock使用类的类对象作为类锁
1.8.线程安全方法与线程不安全方法
如果一个对象的所有的public方法都是同步方法，也就是说是public方法是线程安全的，那该对象的private方法，在不考虑继承的情况下，可以设置为不是线程安全的方法。
参考 thread.lock.SynMethrodAndNotSynMethrod
1.9类锁和实例锁混合使用
在实例方法中混合使用类锁和实例锁；可以根据前面说的那样使用实例锁和类锁。
在类方法中混合使用类锁和实例锁，可以根据前面说的那样使用类锁，为了使用实例锁，先得生成一个实例，然后实例锁。
参考 thread.lock.StaticLockAndObjLock
1.10锁的粒度问题。
为了解决对象锁的粒度过粗，会导死锁出现的可能性加大，锁的粒度过细，
会程序开发维护的工作加大。对于锁的粒度大小，这完全要根据实际开发需要来考虑，很难有一个统一的标准。
1.11.读写锁
一个读写锁支持多个线程同时访问一个对象，但是在同一时刻只有一个线程可以修改此对象，并且在访问进行时不能修改。
有2种调度策略，一种是读锁优先，另外就是写锁优先。
参考 thread.lock.ReadWriteLock
1.12 volatile
在Java中设置变量值的操作，除了long和double类型的变量外都是原子操作，也就是说，对于变量值的简单读写操作没有必要进行同步。这在JVM 1.2之前，Java的内存模型实现总是从主存读取变量，是不需要进行特别的注意的。而随着JVM的成熟和优化，现在在多线程环境下volatile关键字的使用变得非常重要。在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。要解决这个问题，只需要像在本程序中的这样，把该变量声明为volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应该加volatile修饰。
2．线程之间的通讯
在其他语言中，线程之间可以通过消息队列，共享内存，管道等方式来实现线程之间的通讯，但是java中可以不采用这样方式，关注的是线程之间的同步。只要保证相关方法运行的线程安全，信息共享是自然就可以显现了。
2.1屏障
屏障就是这样的一个等待点: 一组线程在这一点被同步，这些线程合并各自的结果或者运行到整体任务的下一阶段。
参考：
thread.lock. BarrierUseExample
thread.lock.Barrier
2.2.锁工具类
提供对线程锁的获取，释放功能。展示了锁的获取释放过程。可以作为一个工具类来使用。
参考：thread.lock. BusyFlag
2.3.条件变量
条件变量是POSIX线程模型提供的一种同步类型，和java中的等待通知机制类似。
虽然java中已经有了等待通知机制，但是为了减少在notify/notifyAll方法中线程调度的开销，把一些不需要激活的线程屏蔽出去，引入了条件变量。
Java中2个（多个）条件变量可以是同一个互斥体（锁对象）。
参考：thread.lock.CondVar 条件变量类
常见的应用情形：
一个锁控制多个信号通道（例如：多个变量），虽然可以采用简单java 等待通知机制，但是线程调度效率不高，而且线程可读性也不是太好，这时候可以采用创建一个锁对象(BusyFlag实例)，同时使用这个BusyFlag实例来创建多个条件变量(CondVar 实例)。
经常使用到CondVar类的地方是缓冲区管理，比如：管道操作之类的。
先创建一个BusyFlag实例，然后创建CondVar 实例，用这个条件变量描述缓冲区是否为空，另外创建CondVar 实例作条件变量述缓冲区是否满。
现实中，马路的红绿灯，就可以采用条件变量来描述。
3. Java线程调度
3.1 Java优先级
java的优先级别共有10种，加上虚拟机自己使用的优先级别=0这种，总共11种。
大多数情况来说，java线程的优先级设置越高（最高=10），那线程越优先运行。
3.2. 绿色线程
线程运行在虚拟机内，操作系统根本不知道这类线程的存在。
线程是由虚拟机调度的。
3.3 本地线程
线程是由运行虚拟机的操作系统完成的。
3.4 Windows本地线程
操作系统，完全能够看得到虚拟机内的每一个线程，同时虚拟机的线程和操作系统的线程是一一对应的。Java的线程调度室由操作系统底层线程决定的。在win32平台下，windows线程只有6个优先级别。和java线程优先级别对应如下：
3.5线程优先级倒置与继承
如果一个线程持有锁(假设该线程名字=ThreadA,优先级别=5)，另外一个线程(假设该线程名字=ThreadB,优先级别=7),现在该线程(ThreadA)处于运行状态，但是线程ThreadB申请需要持有ThreadA所获得的锁，这时候，为了避免死锁，线程A提高其运行的优先级别（提高到ThreadB的优先级别=7）,而线程ThreadB 为了等待获得锁，降低线程优先级别(降低到ThreadA原来的优先级别=5).
上述的这种情况，对于ThreadA,继承了ThreadB的优先级别，这成为优先级别的继承；对于ThreadB暂时降低了优先级别，成为优先级别的倒置。
当然，一旦线程ThreadA持有的锁释放了，其优先级别也会回到原来的优先级别（优先级别=5）。线程ThreadB获得了相应的锁，那优先级别也会恢复到与原来的值(优先级别=7)。
3.6循环调度
具有同样优先级的线程相互抢占成为循环调度。
4.线程池
创建一个线程也是需要一定代价的,为了降低这个代价，采用了和普通对象
池的思想建立线程池，以供系统使用。
线程消耗包括内存和其它系统资源在内的大量资源。除了Thread对象所需的内存之外，每个线程都需要两个可能很大的执行调用堆栈。除此以外，JVM 可能会为每个Java 线程创建一个本机线程，这些本机线程将消耗额外的系统资源。最后，虽然线程之间切换的调度开销很小，但如果有很多线程，环境切换也可能严重地影响程序的性能。
使用线程池的方式是，先建立对象池，然后申请使用线程，程序线程运行，运行完毕，把线程返回线程池。
使用线程池的风险：同步错误和死锁，与池有关的死锁、资源不足和线程泄漏。
大家有空可以研究一下tomcat的线程池实现原理思想。
实际上是tomcat已经在从线程池的使用线程时候加上了事件处理机制。
个人认为，线程池之类的实现，一般不要自己实现，因为自己实现主要是稳定性等方面可能作的不够好。
可以参考 apache的jakarta-tomcat-5.5.6的相关代码，具体是：
jakarta-tomcat-connectors\util\java\org\apache\tomcat\util\thread s的相关代码
5工作队列
使用工作队列的好处是不象直接使用线程池那样，当线城池中没有线程可以使用的时
候，使用者需要处于等待状态，不能进行其他任务的处理。
工作队列的工作原理是：
采用后台线程处理方式，客户端把任务提交给工作队列，工作队列有一组内部可以工作线程，这些工作线程从工作队列中取出任务运行，一个任务完成后，就从队列获取下一个任务进行处理。当工作队列中没有任务可以处理时候，工作线程就处于等待状态，直到获得新的任务时候，才进行新的处理。
参考：
thread.workqueue. WorkQueue简单的工作队列类
thread.workqueue. WorkerThread 工作队列内部线程类
带有事件监听功能的队列
thread.workqueue. WorkQueueWithListener
thread.workqueue.WorkerThreadWithListener
6.参考资料
Java 理论与实践: 流行的原子
https://www.360docs.net/doc/3614600179.html,/developerWorks/cn/java/j-jtp11234/index.shtml
如果我是国王：关于解决 Java 编程语言线程问题的建议
https://www.360docs.net/doc/3614600179.html,/developerWorks/cn/java/j-king/index.shtml
线程-内存模型的缺陷和增强
https://www.360docs.net/doc/3614600179.html,/target/news.php?news_id=2888
ReadWriteLock
https://www.360docs.net/doc/3614600179.html,/PmWiki/pmwiki.php/DesignPattern/ReadWrit eLock
Java Thread实现读写同步
https://www.360docs.net/doc/3614600179.html,/article/17/17487.shtm
破除java神话之三：原子操作都是线程安全的
https://www.360docs.net/doc/3614600179.html,/article/showarticle.jsp?column=1&thread=498
Java线程
Scott Oaks, Henry Wong 第二版O'reilly 中国电力出版社 ISBN 7-5083-1318-6 2003年5月出版
Java Threads, 3rd Edition
Scott Oaks, Henry Wong
September 13, 2004
https://www.360docs.net/doc/3614600179.html,/exec/obidos/ASIN/0596007825/qid=1105151707/sr=2-2/ref=pd_ka_b_2_2/103-3351785-3026256
Taming Java Threads
Allen Holub
https://www.360docs.net/doc/3614600179.html,/exec/obidos/ASIN/1893115100/qid=110515170 7/sr=2-3/ref=pd_ka_b_2_3/103-3351785-3026256
Concurrent Programming in Java(TM): Design Principles and Pattern (2nd Edition)
Doug Lea 1999
https://www.360docs.net/doc/3614600179.html,/exec/obidos/tg/detail/-/020*******/ ref=pd_sim_b_3/103-3351785-3026256?%5Fencoding=UTF8& v=glance
Java 理论与实践：线程池与工作队列
https://www.360docs.net/doc/3614600179.html,/developerWorks/cn/java/j-jtp0730/index.shtml
RTThreadPool设计分析
https://www.360docs.net/doc/3614600179.html,/rt_embed/rt/RTThreadPool.html
JAVA：谈谈Thread Pool
https://www.360docs.net/doc/3614600179.html,/club/essence/200107/3532.htm
Overview of package java.util.concurrent Release 1.3.4.
https://www.360docs.net/doc/3614600179.html,/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html Java.Util.concurrent工具包概述
https://www.360docs.net/doc/3614600179.html,/rt_embed/rt/util_concurrent_tools.html
Java多线程和输入输出流
班级：13科技2班学号：201324131225 姓名：许耿宁 Java多线程和输入输出流 一、实验目的： 1.熟悉利用Thread类建立多线程方法。 2.熟悉利用Thread接口建立多线程方法。 3.熟悉Java的文件读写机制，练习输入输出流的使用。 二、实验内容： 1.阅读下列程序，分析并上机检验其功能。 public class DelayRunnable implements Runnable{ private static int count=0; private int no; private int delay; public DelayRunnable(){ count++; no=count; } public void run(){ try{ for (int i=0;i<10;i++){ delay=(int)(Math.random()*5000); Thread.sleep(delay); System.out.println("Thread "+no+" with a delay "+delay); } }catch(InterruptedException e){} } } class MyRunnable{ public static void main(String args[]){ DelayRunnable r1 = new DelayRunnable();
DelayRunnable r2 = new DelayRunnable(); Thread thread1=new Thread(r1); Thread thread2=new Thread(r2); thread1.start(); thread2.start(); try{ Thread.sleep(1000); }catch(InterruptedException e){ System.out.println("Thread wrong"); } } } 2.将上列程序利用Runnable接口改写，并上机检验。 3.创建简单的程序ThreeThread.java，该程序将创建三个线程，每个线程应当显示它所运行的时间（可以考虑使用Date类或Calendar类）。 4.键盘输入10个整数，从小到大进行排序。 5.接收键盘输入的字符串，用FileInputStream类将字符串写入文件，用 FileOutputStream类读出文件内容显示在屏幕上。 6.将一个文本文件的内容按行读出，每读出一行就顺序加上行号，并写入到另一个文件中。 三、实验要求： 1.通过实验掌握Thread 、Runnable使用方法； 2.程序必须能够实现多线程； 3.程序必须能够完成题目要求； 4.通过实验掌握文件输入输出流的使用方法； 5.程序必须能够从键盘接收字符串并保存在文件中； 6.程序必须能够读出文件内容显示在屏幕上； 7.写出实验报告。 四、实验代码及截图： 第一题： 在编译器上运行程序得到截图所示结果：
4：一个经典的多线程同步问题汇总
一个经典的多线程同步问题 程序描述： 主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。 要求： 1．子线程输出的线程序号不能重复。 2．全局变量的输出必须递增。 下面画了个简单的示意图： 分析下这个问题的考察点，主要考察点有二个： 1．主线程创建子线程并传入一个指向变量地址的指针作参数，由于线程启动须要花费一定的时间，所以在子线程根据这个指针访问并保存数据前，主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。 2．子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。 下面列出这个程序的基本框架，可以在此代码基础上进行修改和验证。 //经典线程同步互斥问题 #include
HANDLE handle[THREAD_NUM]; int i = 0; while (i < THREAD_NUM) { handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); i++;//等子线程接收到参数时主线程可能改变了这个i的值} //保证子线程已全部运行结束 WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); return 0; } unsigned int__stdcall Fun(void *pPM) { //由于创建线程是要一定的开销的，所以新线程并不能第一时间执行到这来int nThreadNum = *(int *)pPM; //子线程获取参数 Sleep(50);//some work should to do g_nNum++; //处理全局资源 Sleep(0);//some work should to do printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum); return 0; } 运行结果：
java多线程面试题
java多线程面试题 1.什么是多线程编程？什么时候使用？ 多线程一般用于当一个程序需要同时做一个以上的任务。多线程通常用于GUI交互程序。一个新的线程被创建做一些耗时的工作，当主线程保持界面与用户的交互。 2.为什么wait(),notify()和notifyall()函数定义在Object类里面? 因为所有类都是继承于Object类，这样所有类就可以简单的进行多线程编程了。 3.wait()方法和sleep()方法有什么不同？ sleep()方法执行后仍然拥有线程，只是延时。而wait方法放弃了线程控制，其它线程可以运行，想要再次运行是要重新开始。 4.Thread和Runnable有什么不同？ JA V A线程控制着程序执行的主路径。当你用java命令调用JVM时，JVM创建了一个隐式线程来执行main方法。Thread类提供了主线程调用其它线程并行运行的机制。 Runnable接口定义了一个能被Thread运行的类。实现Runnable的类只需要实行run方法。可以很灵活的扩展现在的已经继承自其它父类的类。而thread则不可以，因为java 只允许继承一个父类。 Runnable可以共享数据，Thread是一个类，而Runnable是一个接口 5.我可以重载start()方法么？ 可以重载，重载后还要重载run（）方法， 9.编译运行下面的代码会发生什么？ 1.public class Bground extends Thread{ 2.public static void main(String argv[]) 3.{ 4. Bground b = new Bground(); 5. b.run(); 6.} 7.public void start()
it人员的实习工作总结
it人员的实习工作总结 it人员实习工作总结 时光飞逝，转眼了大三就结束了，经过三年的校园专业知识的学习，我将要步入社会参加工作，暑假到了，此时的我和同学们在学院领导老师的安排下，利用暑假时间，参加了这次专业实习。 此次实习的地点是xx一个IT公司，时间是一个月，我选的专业实习方向是大数据开发;大数据开发是以Java编程为基础，然后做大数据架构，数据导入，HDFS分布式文件系统，Hadoop 体系，环境搭建，云计算;因为时间相当有限，因此我们这次实习只学习了Java编程的基础。 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java 语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点[2] 。Java可以编写桌面应用程序、Web应用程序、分
布式系统和嵌入式系统应用程序等。桌面应用程序，又称为GUI 程序(Graphical User Interface)，但是和GUI 程序也有一些区别。桌面应用程序将GUI 程序从GUI具体为“桌面”，使冷冰冰的像块木头一样的电脑概念更具有人性化，更生动和富有活力。运行桌面应用程序时，用户界面会出现在运行应用程序的机器屏幕上。应用程序和它的用户界面之间的消息通过机器的操作系统进行传递。通常情况下，这里只涉及到一台机器，不存在网络。 我们是通过做项目实战来学习Java编程的，在这一个月中，我们做了两个Java项目，一个是桌面应用程序：图书进销存系统，另一个是web应用程序：学生信息管理系统。 第一个项目是图书进销存系统，图书进销存系统是CS结构的，CS结构即客户端-服务器结构，使用的是eclipse集成开发环境，MySQL数据库进行该软件的开发;该系统的主要有出版社管理、书本管理、书的入库管理、销售管理等功能，通过这些简单的功能，可以让我们了解如何利用JDBC进行数据库操作、如何使用Java的反射机制以及如何对系统进行分层等知识点。在实现功能前，我们需要为这个系统建立界面和设计数据库。该系统共有六个界面，包括登录界面、销售管理界面、入库管理界面、书本管理界面、种类管理界面、出版社管理界面。设计数据库方面，该系统使用的是MySQL5.0作为数据库。在设计数据库前，我们可以确定，系统相关的表，从最基础开始，有出版社表、书
JAVA 面试题总览(书签完整版)
JAVA面试题总览 JAVA基础 1.JAVA中的几种基本数据类型是什么，各自占用多少字节。 2.String类能被继承吗，为什么。 3.String，Stringbuffer，StringBuilder的区别。 4.ArrayList和LinkedList有什么区别。 5.讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数， 字段，当new的时候，他们的执行顺序。 6.用过哪些Map类，都有什么区别，HashMap是线程安全的吗,并发下使用的Map是什么， 他们内部原理分别是什么，比如存储方式，hashcode，扩容，默认容量等。 7.JAVA8的ConcurrentHashMap为什么放弃了分段锁，有什么问题吗，如果你来设计， 你如何设计。 8.有没有有顺序的Map实现类，如果有，他们是怎么保证有序的。 9.抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接 口么。 10.继承和聚合的区别在哪。 11.IO模型有哪些，讲讲你理解的nio，他和bio，aio的区别是啥，谈谈reactor模型。 12.反射的原理，反射创建类实例的三种方式是什么。 13.反射中，Class.forName和ClassLoader区别。 14.描述动态代理的几种实现方式，分别说出相应的优缺点。 15.动态代理与cglib实现的区别。 16.为什么CGlib方式可以对接口实现代理。 17.final的用途。 18.写出三种单例模式实现。 19.如何在父类中为子类自动完成所有的hashcode和equals实现？这么做有何优劣。 20.请结合OO设计理念，谈谈访问修饰符public、private、protected、default在应 用设计中的作用。 21.深拷贝和浅拷贝区别。 22.数组和链表数据结构描述，各自的时间复杂度。 23.error和exception的区别，CheckedException，RuntimeException的区别。 24.请列出5个运行时异常。 25.在自己的代码中，如果创建一个https://www.360docs.net/doc/3614600179.html,ng.String类，这个类是否可以被类加载器加 载？为什么。
JAVA线程程序设计(小时钟)实验报告(附完整代码)
线程程序设计 一、课题内容和要求 内容：设计和编写一个编写一个指针式时钟程序，应用线程实现时钟的走动。 要求：本实验旨在通过实验，培养学生将JAVA 线程的相关知识点（包括线程调度，线程同步等）有机结合并加以综合应用，在实验中设计多线程程序的能力。 二、设计思路分析 class Clock:一个指针式时钟的主类 class Layout: 添加窗口和时钟组件 class ClockPaint:定义时钟组件 三、概要设计 public class Clock extends JFrame { public static void main(String[] s) ; } class Layout extends JFrame { public Layout(); } class ClockPaint extends JPanel implements Runnable { int x, y, r; int h, m, s; double rad = Math.PI / 180; public ClockPaint(int x, int y, int r); public void paint(Graphics g); public void run(); } 时钟的绘制:
运行时钟: 四、详细设计 import java.awt.*; import javax.swing.*; import java.util.*; public class Clock extends JFrame { public static void main(String[] s) { new Layout(); } } class Layout extends JFrame {// 添加窗口和时钟组件public Layout() { ClockPaint cp = new ClockPaint(20, 20, 70); add(cp);
java线程学习总结
java线程学习总结1(java thread培训总结1) 1．线程中一些基本术语和概念 (2) 1.1线程的几个状态 (2) 1.2 Daemon线程 (2) 1.3锁的定义 (2) 1.4死锁 (2) 1.5.Java对象关于锁的几个方法 (3) 1.6锁对象(实例方法的锁) (3) 1.7类锁 (4) 1.8.线程安全方法与线程不安全方法 (4) 1.9类锁和实例锁混合使用 (4) 1.10锁的粒度问题 (4) 1.11.读写锁 (5) 1.12 volatile (5) 2．线程之间的通讯 (5) 2.1屏障 (6) 2.2.锁工具类 (6) 2.3.条件变量 (6) 3. Java线程调度 (7) 3.1 Java优先级 (7) 3.2. 绿色线程 (7) 3.3 本地线程 (7) 3.4 Windows本地线程 (7) 3.5线程优先级倒置与继承 (8) 3.6循环调度 (8) 4.线程池 (8) 5工作队列 (9) 6.参考资料 (10)
1．线程中一些基本术语和概念 1.1线程的几个状态 初始化状态 就绪状态 运行状态 阻塞状态 终止状态 1.2 Daemon线程 Daemon线程区别一般线程之处是：主程序一旦结束，Daemon线程就会结束。 1.3锁的定义 为了协调多个并发运行的线程使用共享资源才引入了锁的概念。 1.4死锁 任何多线程应用程序都有死锁风险。当一组线程中的每一个都在等待一个只 有该组中另一个线程才能引起的事件时，我们就说这组线程死锁了。换一个说法就是一组线程中的每一个成员都在等待别的成员占有的资源时候，就可以说这组线程进入了死锁。死锁的最简单情形是：线程 A 持有对象X 的独占锁，并且在等待对象Y 的锁，而线程 B 持有对象Y 的独占锁，却在等待对象X 的锁。除非有某种方法来打破对锁的等待（Java 锁定不支持这种方法），否则死锁的线程将永远等下去。
多线程常见面试题
1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完 后执行？ T1.start(); T1.join(); T2.start(); T2.join(); T3.start() 2)11) 为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run() 方法？ start()方法最本质的功能是从CPU中申请另一个线程空间来执行run()方法中的代码,它和当前的线程是两条线,在相对独立的线程空间运行 ,也就是说,如果你直接调用线程对象的run()方法,当然也会执行,但那是在当前线程中执行,run()方法执行完成后继续执行下面的代码.而调用start()方法后,run()方法的代码会和当前线程并发(单CPU)或并行(多CPU)执行。 调用线程对象的run方法不会产生一个新的线程 3)在java中wait和sleep方法的不同？ sleep()睡眠时，保持对象锁，仍然占有该锁； 而wait()睡眠时，释放对象锁。 sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会; sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。 在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。 wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问； wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。 wiat()必须放在synchronized block中，否则会在program runtime时扔出”https://www.360docs.net/doc/3614600179.html,ng.IllegalMonitorStateException“异常。 4)为什么wait, notify 和notifyAll这些方法不在thread类里面？ 因为这些是关于锁的 而锁是针对对象的 锁用于线程的同步应用 决定当前对象的锁的方法就应该在对象中吧 我是这么理解的希望对你有帮助
JAVA暑期实习报告
实习总结报告 实习总结报告 一、实习目的 Java语言是一种高级计算机语言，具有简单，面向对象，安全，跨平台，支持多线程的特点。这次实习的目的是使我们掌握JA V A的基本知识，能运用JA V A来编写程序，解决一般性的问题，使得我们在完成本课程学习后，掌握JA V A的基本知识和初步的编程能力，为以后的学习和工作提供了一个非常有用的工具。 2、实习内容 1.鼠标拖动小球运动 …
MouseMotionListener{ //Graphics代表画笔 super.paint(g);//调用父类的paint方法 //设置画笔颜色 g.setColor(Color.BLUE); /*x,y代表要填充的圆弧的左上角坐标 代表填充圆弧的宽度 代表填充圆弧的高度 相对于开始角度，圆弧的跨越度*/ } @Override
x=e.getX();//获得圆心坐标 y=e.getY(); repaint();//重新画一个小球} @Override x=e.getX();//获得圆心坐标 y=e.getY(); repaint();//重新画一个小球 } x=200; y=200;//为小球坐标赋初始值 //为当前面板添加鼠标移动事件监听 this.addMouseMotionListener(this); }
public class MouseBallFrame extends JFrame{ public static void main(String[]args){ MouseBallFrame frame=new MouseBallFrame(); MouseBallPanel panel=new MouseBallPanel(); frame.add(panel); frame.setSize(1024,768); frame.setTitle("鼠标控制小球"); frame.setVisible(true); } } 这是第一次成功的设置窗口，面板，并将JA V A程序结果在窗口内显示，这似乎打开了另外一扇门，有更多的知识等着我去探索。（结果如图1） 图1 2.小球运动的屏幕保护程序
精选大厂java多线程面试题50题
Java多线程50题 1)什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。 2)线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。更多详细信息请点击这里。 3)如何在Java中实现线程？ https://www.360docs.net/doc/3614600179.html,ng.Thread类的实例就是一个线程但是它需要调用https://www.360docs.net/doc/3614600179.html,ng.Runnable接口来执行，由于线程类本身就是调用的 Runnable接口所以你可以继承https://www.360docs.net/doc/3614600179.html,ng.Thread类或者直接调用Runnable接口来重写run()方法实现线程。 4)Thread类中的start()和run()方法有什么区别？ 这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你
调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。 5)Java中Runnable和Callable有什么不同？ Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。它们的主要区别是Callable的call()方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象。 6)Java内存模型是什么？ Java内存模型规定和指引Java程序在不同的内存架构、CPU 和操作系统间有确定性地行为。它在多线程的情况下尤其重要。 Java内存模型对一个线程所做的变动能被其它线程可见提供了保证，它们之间是先行发生关系。 ●线程内的代码能够按先后顺序执行，这被称为程序次序 规则。 ●对于同一个锁，一个解锁操作一定要发生在时间上后发 生的另一个锁定操作之前，也叫做管程锁定规则。 ●前一个对Volatile的写操作在后一个volatile的读操作之 前，也叫volatile变量规则。 ●一个线程内的任何操作必需在这个线程的start()调用之 后，也叫作线程启动规则。 ●一个线程的所有操作都会在线程终止之前，线程终止规
JAVA语言程序设计课程设计报告模板及范文
设计题目：仿Windows画笔系统设计专业：计算机科学与技术 班级： 学号： 姓名： 2015 年7月
中文摘要 摘要：随着科学技术的不断提高，计算机科学日渐成熟，其强大的功能已为人们深刻认识，它已进入人类社会的各个领域并发挥着越来越重要的作用。 JAVA是一门很优秀的编程语言，具有面向对象、与平台无关、安全、稳定和多线程等特点，是目前软件设计中极为健壮的编程语言。JAVA不仅可以用来开发大型的应用程序。而且特别适合Internet的应用开发。JAVA确实具备“一次写成，处处运行”的特点，JAVA以成为网络时代最重要的编程语言之一。本报告中介绍了用JAVA语言实现画笔系统的全部过程。 本次课程设计是配合JAVA程序设计课程，帮助我们深入学习掌握JAVA语言，熟练运用这个工具来编写的。通过课程设计各个项目的综合训练，培养学生实际分析问题、编程和动手能力、提高学生的综合素质。本课程设计尝试使用一些较生动的示例和设计项目，激发学生学习兴趣，引导学生主动学习，正确理解、接受需要重点掌握的知识点，为参加项目开发及更深入学习做好准备。 本次课程设计主要是用JAVA实现画笔系统，其系统主要完成以下功能：设计一个画图程序，能够实现画笔、画直线、画圆形、画矩形的功能，并且在绘图。过程中能够修改该画笔的大小以及颜色。该画图程序还需具有橡皮擦功能以及清空整个画面的功能 关键词：画笔系统，JA V A
目录 中文摘要 (2) 目录 (3) 1.绪论 (4) 2. 开发环境介绍 (4) 3.需求分析 (5) 3.1总体目标 (5) 3.2要实现的功能 (6) 4.概要设计 (6) 4.1设计准备 (6) 4.2需用到的类 (7) 5.详细设计 (7) 5.1类的设计 (7) 5.2类的方法介绍 (8) 6.测试数据及运行结果 (10) 7.总结 (11) 8.参考文献 (11) 9.源程序 (12)
多线程总结
最近想将java基础的一些东西都整理整理，写下来，这是对知识的总结，也是一种乐趣。已经拟好了提纲，大概分为这几个主题： java线程安全，java垃圾收集，java并发包详细介绍，java profile和jvm性能调优。慢慢写吧。本人jameswxx原创文章，转载请注明出处，我费了很多心血，多谢了。关于java线程安全，网上有很多资料，我只想从自己的角度总结对这方面的考虑，有时候写东西是很痛苦的，知道一些东西，想用文字说清楚，却不是那么容易。我认为要认识 java线程安全，必须了解两个主要的点：java的内存模型，java的线程同步机制。特别是内存模型，java的线程同步机制很大程度上都是基于内存模型而设定的。从暂时写得比较仓促，后面会慢慢补充完善。 浅谈java内存模型 不同的平台，内存模型是不一样的，但是jvm的内存模型规范是统一的。java的多线程并发问题最终都会反映在java的内存模型上，所谓线程安全无非要控制多个线程对某个资源的有序访问或修改。java的内存模型，要解决两个主要的问题：可见性和有序性。我们都知道计算机有高速缓存的存在，处理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型，屏蔽了底层平台内存管理细节，对于java开发人员，要解决的是在jvm内存模型的基础上，如何解决多线程的可见性和有序性。 那么，何谓可见性？多个线程之间是不能互相传递数据通信的，它们之间的沟通只能通过共享变量来进行。Java内存模型（JMM）规定了jvm有主内存，主内存是多个线程共享的。当new一个对象的时候，也是被分配在主内存中，每个线程都有自己的工作内存，工作内存存储了主存的某些对象的副本，当然线程的工作内存大小是有限制的。当线程操作某个对象时，执行顺序如下： (1) 从主存复制变量到当前工作内存 (read and load) (2) 执行代码，改变共享变量值 (use and assign) (3) 用工作内存数据刷新主存相关内容 (store and write) JVM规范定义了线程对主存的操作指令：read，load，use，assign，store，write。当一个共享便变量在多个线程的工作内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值，这就是多线程的可见性问题。 那么，什么是有序性呢？线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本 (use),也就是说 read,load,use顺序可以由JVM实现系统决定。 线程不能直接为主存中中字段赋值，它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write)，至于何时同步过去，根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线程会引用该变量副本，当同一线程多次重复对字段赋值时,比如： for(int i=0;i<10;i++) a++; 线程有可能只对工作内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区，所以assign,store,weite顺序可以由JVM实现系统决定。假设有一个共享变量x，线程a执行x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作，它的执行过程如下：
JAVA重点知识总结
CoreJava部分 1简述下java基本数据类型及所占位数，java基本数据类型：4类8种 整数类型：byte(1byte),short(2byte),int(4byte),long(8byte) 浮点类型：float(4byte),double(8byte) 字符类型：char(2byte) 逻辑类型：boolean(false/true1byte) 2说出5个启动时异常 ------RunTimeException ------NullPointerException ------ArrayIndexOutOfBoundsException ------ClassCastException ------NumberFormatException 3HashMap和HashTable的区别： 1HashMap允许空键值对，HashTable不允许 2HashMap不是线程安全的，HashTable是 3HashMap直接实现Map接口，HashTable继承Dictionary类 4.ArrayList,Vector,LinkedList存储性能和区别 它们都实现了List接口 ArrayList和Vector都是基于数组实现的 LinkedList基于双向循环链表（查找效率低，添加删除容易） ArrayList不是线程安全的而Vector是线程安全的，所有速度上ArrayList高于Vector 5.Collection和Collections的区别 Collection是集合类的上级接口，继承与他的接口主要有Set和List Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作。 6List、Map、Set三个接口，存取元素时，各有什么特点？ List以特定次序来持有元素，可有重复元素。 Set无法持有重复元素，内部排序 Map保存key-value值，value可多值。 7final,finally,finalize的区别 Final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承Finally是异常处理语句结构的一部分，表示总是执行 Finalize是Object类的一个方法，在垃圾收集时的其他资源回收，例如关闭文件等。8Overload和Override的区别。Overload的方法是否可以改变返回值的类型？ 方法的重写Override和重载Overload是Java多态的不同表现。 重写Overriding是父类与子类之间多态的一种表现，方法名，参数列表返回值类型都得与父类的方法一致。 重载Overloading是一种类中多态的一种表现。重载的方法是可以改变返回值类型的。9用一句话总结一下冒泡排序 依次比较相邻的两个数，将小数放在前面，大数放在后面。 10实现线程安全的两种方式 1）synchronized方法：通过在方法声明加入synchronized关键字来声明synchronized方法
2019最新Java面试题,常见面试题及答案汇总
ava最新常见面试题+ 答案汇总 1、面试题模块汇总 面试题包括以下十九个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。如下图所示： 可能对于初学者不需要后面的框架和JVM 模块的知识，读者朋友们可根据自己的情况，选择对应的模块进行阅读。 适宜阅读人群 需要面试的初/中/高级java 程序员 想要查漏补缺的人 想要不断完善和扩充自己java 技术栈的人 java 面试官 具体面试题 下面一起来看208 道面试题，具体的内容。 一、Java 基础 1.JDK 和JRE 有什么区别？ 2.== 和equals 的区别是什么？ 3.两个对象的hashCode()相同，则equals()也一定为true，对吗？ 4.final 在java 中有什么作用？ 5.java 中的Math.round(-1.5) 等于多少？ 6.String 属于基础的数据类型吗？ 7.java 中操作字符串都有哪些类？它们之间有什么区别？ 8.String str="i"与String str=new String(“i”)一样吗？ 9.如何将字符串反转？ 10.String 类的常用方法都有那些？ 11.抽象类必须要有抽象方法吗？ 12.普通类和抽象类有哪些区别？ 13.抽象类能使用final 修饰吗？
14.接口和抽象类有什么区别？ 15.java 中IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 二、容器 18.java 容器都有哪些？ 19.Collection 和Collections 有什么区别？ 20.List、Set、Map 之间的区别是什么？ 21.HashMap 和Hashtable 有什么区别？ 22.如何决定使用HashMap 还是TreeMap？ 23.说一下HashMap 的实现原理？ 24.说一下HashSet 的实现原理？ 25.ArrayList 和LinkedList 的区别是什么？ 26.如何实现数组和List 之间的转换？ 27.ArrayList 和Vector 的区别是什么？ 28.Array 和ArrayList 有何区别？ 29.在Queue 中poll()和remove()有什么区别？ 30.哪些集合类是线程安全的？ 31.迭代器Iterator 是什么？ 32.Iterator 怎么使用？有什么特点？ 33.Iterator 和ListIterator 有什么区别？ 34.怎么确保一个集合不能被修改？
JAVA项目实验报告
JA V A课程项目报告 项目题目：利用JA V A实现一个小时钟的程序专业班级：10软件工程 学生姓名：闵楠 学生学号：E01014135
利用JAVA实现一个时钟的小程序 1.软件开发的需求分析 在当今的信息时代，时钟已经成为人们生活中必不可少的应用工具，Java语言是当今流行的网络编程语言，它具有面向对象、与平台无关、安全、多线程等特点。使用Java 语言不仅可以实现大型企业级的分布式应用系统，还能够为小型的、嵌入式设备进行应用程序的开发。面向对象的开发方法是当今世界最流行的开发方法，它不仅具有更贴近自然的语义，而且有利于软件的维护和继承。为了进一步巩固课堂上所学到的知识，深刻把握Java 语言的重要概念及其面向对象的特性，锻炼我们熟练的应用面向对象的思想和设计方法解决实际问题的能力，开设了Java程序设计课程设计。 此次课程设计的题目为简单的小时钟程序设计，通过做巩固所学Java语言基本知识，增进Java语言编辑基本功，掌握JDK、JCreator等开发工具的运用，拓宽常用类库的应用。使我们通过该教学环节与手段，把所学课程及相关知识加以融会贯通，全面掌握Java语言的编程思想及面向对象程序设计的方法，为今后从事实际工作打下坚实的基础。 2．具体实现 2.1设计思路 Java是一种简单的，面向对象的，分布式的，解释的，键壮的，安全的，结构中立的，可移植的，性能很优异的，多线程的，动态的语言。Java去掉了C++语言的许多功能，让Java的语言功能很精炼，并增加了一些很有用的功能，如自动收集碎片。这将减少平常出错的50%。而且，Java很小，整个解释器只需215K的RAM。 因此运用JAVA程序编写小时钟程序，实现简单显示时间的功能。本次课程设计做的是Java简单小时钟，它是图形界面、线程、流与文件等技术的综合应用，其界面主要采用了java.awt包,javax.swing包等。程序实现了小时钟的基本功能。 2.2设计方法 在设计简单小时钟时，需要编写5个Java源文件：Server.java、Objecting.java、LogIn.java、ClientUser.java、Client.java。 小时钟除了需要编写的上述5个Java源文件所给出的类外，还需要Java系统提供的一些重要的类，如JTextField、JTextArea和File类。
java学习整体总结
CoreJava部分 1 简述下java基本数据类型及所占位数，java基本数据类型：4类8种 整数类型：byte(1byte),short(2byte),int(4byte),long(8byte) 浮点类型：float(4byte),double(8byte) 字符类型：char(2byte) 逻辑类型：boolean(false/true 1byte) 2 说出5个启动时异常 RunTimeException ------NullPointerException ------ArrayIndexOutOfBoundsException ------ClassCastException ------NumberFormatException 3 HashMap 和HashTable的区别： 1HashMap 允许空键值对，HashTable不允许 2HashMap不是线程安全的，HashTable是 3HashMap直接实现Map接口，HashTable继承Dictionary类 4. ArrayList,Vector,LinkedList存储性能和区别 它们都实现了List接口 ArrayList和Vector都是基于数组实现的 LinkedList基于双向循环链表（查找效率低，添加删除容易） ArrayList不是线程安全的而Vector是线程安全的，所有速度上 ArrayList高于Vector 5. Collection和Collections的区别 Collection是集合类的上级接口，继承与他的接口主要有Set和List Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作。 6 List、Map、Set三个接口，存取元素时，各有什么特点？ List以特定次序来持有元素，可有重复元素。 Set 无法持有重复元素，内部排序 Map保存key-value值，value可多值。 7 final,finally,finalize的区别 Final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承 Finally 是异常处理语句结构的一部分，表示总是执行 Finalize 是Object类的一个方法，在垃圾收集时的其他资源回收，例如关闭文件等。 8 Overload和Override的区别。Overload的方法是否可以改变返回值的
15个Java多线程面试题及答案
15个Java多线程面试题及答案 1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行? 这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。 2)在Java中Lock接口比synchronized块的优势是什么?你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它? lock接口在多线程和并发编程中最大的优势是它们为读和写分别提 供了锁，它能满足你写像ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。芯学苑老师强烈建议在你在面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。 3)在java中wait和sleep方法的不同?
通常会在电话面试中经常被问到的Java线程面试问题。最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。 4)用Java实现阻塞队列。 这是一个相对艰难的多线程面试问题，它能达到很多的目的。第一，它可以检测侯选者是否能实际的用Java线程写程序;第二，可以检测侯选者对并发场景的理解，并且你可以根据这个问很多问题。如果他用wait()和notify()方法来实现阻塞队列，你可以要求他用最新的Java 5中的并发类来再写一次。 5)用Java写代码来解决生产者——消费者问题。 与上面的问题很类似，但这个问题更经典，有些时候面试都会问下面的问题。在Java中怎么解决生产者——消费者问题，当然有很多解决方法，我已经分享了一种用阻塞队列实现的方法。有些时候他们甚至会问怎么实现哲学家进餐问题。 6)用Java编程一个会导致死锁的程序，你将怎么解决?
编程学习心得和方法
编程学习心得和方法 )基于VB(https://www.360docs.net/doc/3614600179.html,)，JSP基于JAVA。 现今已经发展出各种各样的编程语言，并且，它们大多采用了英文编写，单是关键字和标准类库就要我们花时间去记忆和识别，最后，还得去灵活运用更多的东西。所以，我们想一次性学习它们，这是不可能的事情，尽管大多语言很相似，你也不可能做到的。事实上，很少有人能够学习全部，大多都只能擅长某一种。 即便是高级编程人员，像那些为开发软件工作的类库和组件高手，他们也不敢说自己精通每一种语言。事实就是这样，每一种语言有着它们相似而又不同的语法，它们有着不同的关键字，发展出了各种各样的类库，它们的函数或者方法的声明定义都有不同，更多的差异不为我们所知。 每一种语言，它都有着太多的东西需要我们去理解和记忆，我们没有时间和精力做得太多。对于初学者，我们最不应该急于求成，更不要试图一次性学习所有语言。事实上，我们可以选取某种语言学习。每一种语言都有着自己的强大功能，好的语言能够完成所有事情，所以，你不要担心学习一种语言不够全面这样的问题。 当你能够得心应手掌控你学习的一种语言后，你回过头来再去学习其他语言时，你可能会发现，原来，这些语言是那么的相近。这个时候，你再去学习它们，我想，那真是很愉快的事情，大概，那个时候，你会笑出声来。 我们知道，从某种意义来说，各种语言都有很多类似的地方，这大概是因为所有的语言开发都是基于已有语言创造的，开发者也出于对大家的尊重，考虑到易于学习等等原因，他们选择了几乎是相同的语法来定义这些新语言。可以说，所有语言都是基于已有语言开发的，没有人能够聪明到突发其想，更不可能一夜之间发明出一种完全不同的外星语。 基于语言再开发语言，这么做能给使用者带来了一次学习，全部学会的好处。当然，最大的好处莫过于新的语言肯定比之前的语言更加好用简单，功能也更全面强大。某种意义上讲，开发新的语言就是在更新旧语言的错误和不足，最后发展出新语言。 其实，每一种语言的区别大多只在于关键字的区别，还有一些语法上的区别。事实就是这样，很多语言之所以不同，就因为它们的关键字不同。就像你吃饭一样，中国人用筷子，外国人却不是。这些都没有改变吃饭的实质，我们都能完成一样的事情，那就是吃饭。