java的模型

A. java的内存模型是怎么设计的

先来画一个简图，java内存模型可以这样分类：

packagecom.wyq.Memory;

publicclassPerson{
publicStringname;//成员变量，存放在栈中
publicstaticintage;//static类型的变量，存放在静态变量区
publicstaticfinalStringsex="女";//常量在常量池中

publicPerson(Stringname){
this.name=name;
}

publicvoidwalk(Personperson){//传入一个person引用,存放在栈中
intstep=5;//局部变量，基本数据类型，存放在栈中
System.out.println(person.name+"跑了"+step+"步");
}
publicstaticvoidmain(String[]args){
Personperson=newPerson("楼主");//由构造器new一个person对象，存放在堆中
person.walk(person);
}
}
//整个代码在代码区中

B. java并发(1)线程模型

程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念

主要归咎于两点. 一个是由实现决定的,一个是由需求决定的.

线程由线程ID，程序计数器(PC）[用于指向内存中的程序指令]，寄存器集合[由于存放本地变量和临时变量]和堆栈[用于存放方法指令和方袜拍法参数等]组成。

以 Unix/Linux 的体系架构为例。

因为操作系统的资源纳神是有限的，如果访问资源的操作过多，必然会消耗过多的资源，而且如果不对这些操作加以区分，很可能造成资源访问的冲突。所以，为了减少有限资源的访问和使用冲突，对不同的操作赋予不同的执行等级(有多大能力做多大的事)，用户态(User Mode)和内核态(Kernel Mode)。

运行于用户态的进程可以执行的操作和访问的资源都会受到极大的限制，而运行在内核态的进程则可以执行任何操作并且在资源的使用上洞好亏没有限制。

并发 ：一个时间段内有很多的线程或进程在执行，但何时间点上都只有一个在执行，多个线程或进程争抢时间片轮流执行。

并行 ：一个时间段和时间点上都有多个线程或进程在执行。

线程有三种模型, 一对一,多对一,多对多.具体参考 一篇文章读懂Java多线程模型 , 这里只描述一对一的情况.

每个用户线程都映射到一个内核线程，每个线程都成为一个独立的调度单元，由内核调度器独立调度，一个线程的阻塞不会影响到其他线程，从而保障整个进程继续工作.

JVM 没有限定 Java 线程需要使用哪种线程模型来实现， JVM 只是封装了底层操作系统的差异，而不同的操作系统可能使用不同的线程模型，例如 Linux 和 windows 可能使用了一对一模型，solaris 和 unix 某些版本可能使用多对多模型。所以一谈到 Java 语言的多线程模型，需要针对具体 JVM 实现。

Sun JDK 1.2开始，线程模型都是基于操作系统原生线程模型来实现，它的 Window 版和 Linux 版都是使用系统的 1:1 的线程模型实现的。

C. java 的表格模型是什么

DefaultTableModel是常用的java表格模型。

参考代码：

packagecom.sd;

importjava.awt.BorderLayout;
importjava.awt.Container;
importjava.awt.Point;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.awt.event.InputEvent;
importjava.awt.event.MouseAdapter;
importjava.awt.event.MouseEvent;
importjava.awt.event.WindowAdapter;
importjava.awt.event.WindowEvent;
importjava.util.Arrays;
importjava.util.Vector;

importjavax.swing.JButton;
importjavax.swing.JFrame;
importjavax.swing.JLabel;
importjavax.swing.JOptionPane;
importjavax.swing.JPanel;
importjavax.swing.JScrollPane;
importjavax.swing.JTable;
importjavax.swing.JTextField;
importjavax.swing.ListSelectionModel;
importjavax.swing.event.TableModelEvent;
importjavax.swing.event.TableModelListener;
importjavax.swing.table.DefaultTableModel;
importjavax.swing.table.JTableHeader;
importjavax.swing.table.TableColumnModel;

/**
*表格模型事件示例
*<p>
*<li>,
*,orotherwiseinteracts
*withacomponent.,
*-boxismadevisible.
*
*.
*
*@authorHAN
*
*/
{

/**
*
*/
=-8581492063632813033L;

publicTableModel(){
//TODOAuto-generatedconstructorstub
finalContainercontainer=getContentPane();
Vector<String>tableColumnNames=newVector<String>();
tableColumnNames.add("A");
tableColumnNames.add("B");
Vector<Vector<String>>tableValues=newVector<Vector<String>>();
for(inti=1;i<5;i++){
Vector<String>vector=newVector<String>();
vector.add("A"+i);
vector.add("B"+i);
tableValues.add(vector);
}
=newDefaultTableModel(
tableValues,tableColumnNames);
finalJTabletable=newJTable(defaultTableModel);
JScrollPanescrollPane=newJScrollPane();
scrollPane.setViewportView(table);
container.add(scrollPane,BorderLayout.CENTER);
JPanelpanel=newJPanel();
container.add(panel,BorderLayout.SOUTH);
JLabellabelA=newJLabel("A:");
finalJTextFieldtextFieldA=newJTextField(15);
JLabellabelB=newJLabel("B:");
finalJTextFieldtextFieldB=newJTextField(15);
JButtonbuttonAdd=newJButton("添加");
JButtonbuttonDel=newJButton("删除");
JButtonbuttonDeselected=newJButton("取消选择");
panel.add(labelA);
panel.add(textFieldA);
panel.add(labelB);
panel.add(textFieldB);
panel.add(buttonAdd);
panel.add(buttonDel);
panel.add(buttonDeselected);
buttonAdd.addActionListener(newActionListener(){

publicvoidactionPerformed(ActionEvente){
//TODOAuto-generatedmethodstub
int[]selectedRows=table.getSelectedRows();//table
//默认情况容许多行选择
Vector<String>rowData=newVector<String>();
rowData.add(textFieldA.getText());
rowData.add(textFieldB.getText());
if(selectedRows.length==0){
defaultTableModel.addRow(rowData);
textFieldA.setText(null);
textFieldB.setText(null);
}elseif(selectedRows.length==1){
// System.out.println(selectedRows[0]);
defaultTableModel.insertRow(selectedRows[0]+1,rowData);
textFieldA.setText(null);
textFieldB.setText(null);
}else{
JOptionPane.showMessageDialog(container,
"Youroperationisforbidden","Warning",
JOptionPane.WARNING_MESSAGE);
}
}

});
buttonDel.addActionListener(newActionListener(){

publicvoidactionPerformed(ActionEvente){
//TODOAuto-generatedmethodstub
int[]selectedRows=table.getSelectedRows();//table
//默认情况容许多行选择
for(inti=0;i<selectedRows.length;i++){
// System.out.println(selectedRows[i]);
defaultTableModel.removeRow(selectedRows[i]-i);
}
}

});
buttonDeselected.addActionListener(newActionListener(){

publicvoidactionPerformed(ActionEvente){
//TODOAuto-generatedmethodstub
table.clearSelection();
}

});
scrollPane.addMouseListener(newMouseAdapter(){
@Override
publicvoidmouseClicked(MouseEvente){
// System.out.println("here");
if(e.getClickCount()==1
&&e.getButton()==MouseEvent.BUTTON1){
table.clearSelection();
}
}
});

//
addWindowFocusListener(newWindowAdapter(){

@Override
publicvoidwindowGainedFocus(WindowEvente){
//TODOAuto-generatedmethodstub
textFieldA.requestFocus();
}

});

//**************************************************************
//
//Excel
//**************************************************************

//rowselectionmode
table.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
//columnselectionmode
=table.getColumnModel();
tableColumnModel.getSelectionModel().setSelectionMode(
ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
//allowthecolumnselection()
table.setColumnSelectionAllowed(true);
finalJTableHeadertableHeader=table.getTableHeader();
tableHeader.addMouseListener(newMouseAdapter(){
@Override
publicvoidmouseClicked(MouseEvente){
//TODOAuto-generatedmethodstub
//,
//suchasALT,CTRL,META.
if(e.getClickCount()==1
&&e.getButton()==MouseEvent.BUTTON1){
//Pointpoint=newPoint(e.getX(),e.getY());
Pointpoint=newPoint(e.getPoint());
intcolumnNum=tableHeader.columnAtPoint(point);
//System.out.println(columnNum);
int[]selectedColumns=table.getSelectedColumns();
if(selectedColumns.length!=0){
//System.out.println("here1");
//System.out.println(InputEvent.getModifiersExText(e.getModifiersEx()));
if(e.getModifiersEx()==(InputEvent.CTRL_DOWN_MASK)){
// System.out.println("ctrl");
if(Arrays.binarySearch(selectedColumns,columnNum)>=0){
table.removeColumnSelectionInterval(columnNum,
columnNum);
}else{
table.addColumnSelectionInterval(columnNum,
columnNum);
}
}elseif(e.getModifiersEx()==(InputEvent.SHIFT_DOWN_MASK)){
//System.out.println("shift");
table.setColumnSelectionInterval(
selectedColumns[0],columnNum);
}else{
table.setColumnSelectionInterval(columnNum,
columnNum);
}
}else{
//System.out.println("here2");
table.setColumnSelectionInterval(columnNum,columnNum);
}
table.setRowSelectionInterval(0,table.getRowCount()-1);
}
}
});

defaultTableModel.addTableModelListener(newTableModelListener(){

publicvoidtableChanged(TableModelEvente){
//TODOAuto-generatedmethodstub
inttype=e.getType();
intfirstRow=e.getFirstRow();
// intlastRow=e.getLastRow();//
intcolumn=e.getColumn();
switch(type){
caseTableModelEvent.DELETE:
System.out.print("此次事件由删除行触发：");
System.out.println("此次删除的是第"+firstRow+"行");
break;
caseTableModelEvent.INSERT:
System.out.print("此次事件由插入行触发：");
System.out.println("此次插入的是第"+firstRow+"行");
break;
caseTableModelEvent.UPDATE:
System.out.print("此次事件由更新行触发：");
System.out.println("此次更新的是第"+firstRow+"行第"+column+"列");
break;
default:
System.out.println("此次事件由其他原因触发");
}
}

});
}

/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
TableModelframe=newTableModel();
frame.setTitle("表格模型事件示例");
frame.pack();//Realizethecomponents.
// frame.setBounds(100,100,600,300);
// textFieldA.requestFocus();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);//Displaythewindow.
}

}

D. java内存模型的介绍

Java平台自动集成了线程以及多处理器技术，这种集成程度比Java以前诞生的计算机语言要厉害很多，该语言针对多种异构平台的平台独立性而使用的多线程技术支持也是具有开拓性的一面，有时候在开发Java同步和线程安全要求很严格的程序时，往往容易混淆的一个概念就是内存模型。究竟什么是内存模型？内存模型描述了程序中各个变量（实例域、静态域和数组元素）之间的关系，以及在实际计算机系统中将变量存储到内存和从内存中取出变量这样的底层细节，对象最终是存储在内存里面的，这点没有错，但是编译器、运行库、处理器或者系统缓存可以有特权在变量指定内存位置存储或者取出变量的值。【JMM】（Java Memory Model的缩写）允许编译器和缓存以数据在处理器特定的缓存（或寄存器）和主存之间移动的次序拥有重要的特权，除非程序员使用了final或synchronized明确请求了某些可见性的保证。