thread implementation by a kernel versus thread implementation by an application?
346741
What's the question?\n\nThreads implemented by the kernel have somewhat higher overhead (because going into the kernel involves a state switch, crossing protection domains, etc), but such threads can behave better because, for example, a different thread can be dispatched in the case of a page fault, or other kinds of blockage.\n\nThreads implemented by the application (or by the run-time system, running in user state) require voluntary relinquishing of the processor when a thread is blocked.   Some of this can be built into libraries, but is nonetheless a potential source of errors and problems.
162053
What's your OS ?\nin what application does the runtime error occur ?\nhow often does it occur ? (give a rough time between errors)
651565
Swing components are not inherently thread safe, and as a general rule, after Swing components have been made visible on the screen, you can only safely modify their data from the event thread. If you modify Swing component data from any thread other than the event dispatching thread, you must take precautions to ensure data integrity. An exception to this rule is the setText method on a JTextComponent or any of its subclasses, or any Swing component method whose documentation explicitly states it is thread safe. \n\nSometimes, you cannot avoid modifying Swing component data from outside the event dispatching thread after it has been made visible. An example is spawning a thread to handle a long operation such as reading or writing a large file over the net. The advantage to spawning a new thread is that the user interface is made available to the user for other operations during the long file operation. The spawned thread is a new thread, and therefore, not on the event dispatching thread even if it is spawned by an event dispatching thread method. \n\nThis article explains how to use the InvokeLater method and synchronize keyword to ensure data integrity when modifying data in Swing components. If you are new to multi-threaded programming, see Creating a Threaded Slide Show Applet for an introduction to the threaded applications. \n\nFor furthur info please visit:\nhttp://java.sun.com/developer/technicalArticles/Threads/swing/
284572
Uh, it makes Windows run. Without it, there would be trouble!\n\n"  \n  \nKernel32.dll is the 32-bit dynamic link library found in the Windows operating system kernel. It handles memory management, input/output operations, and interrupts. When Windows boots up, kernel32.dll is loaded into a protected memory space so other applications do not take that space over. \n\nOn occasion, though, users may encounter the "invalid page fault" error. \n\n\nThis error occurs when a program or application tries to access kernel32.dll's protected memory space. Sometimes the error is caused by one particular program or application, and other times it is provoked by multiple files and applications. \n\n\nIf the problem results from running one application, then the application needs to be replaced. If the problem occurs when accessing multiple files and applications, the corruption is probably caused by faulty hardware."
21407
As a technology, HyperThreading behaves much differently than dual-core.  HyperThreading allows a single CPU core to queue two threads simultaneously, but only operate on one at-a-time (non HT processors only queue, and operate on, one thread at-a-time).  This helps reduce latency and improve overall performance.  It also means that the operating system need not support multiple processors to take advantage of the feature (Win98, WinME, WinXP Home).\n\nDual-core places two processor cores (where processing takes place) on a single die (chip).  This is effectively the same as having two separate processors on your motherboard (with higher speed interconnects on the dual-core, but close enough).  The operating system must be able to handle multiple cores (Win2000, WinXP Pro, WinServer families) to take advantage of this configuration.\n\nUltimately either technology only benefits individual applications if the applications running on the machine are written to support multiple threads (running two or more tasks at-a-time).  Users who run multiple applications at once that perform background tasks while other applications are busy will also notice better performance.  If either of these two scenarios fit your applications, then either processor will be of some benefit.\n\nIn most scenarios, the dual-core Athlon will perform better at a lower clock speed.  Since some applications are optimized to run on the P4, there are a few exceptions, however (very few).
254178
With GCC compiler (used by Dev-++) you can write:\n\nsystem("cls");
143317
1) Stack overflow and underflow\n2) Memory Leak\n3) Dangling Pointers\n4) Exceptions not handled properly\n5) Null pointer
10383
Pick a simple language like Java to get your feet wet study up on threading and synchronization. I've included a decent link in my sources to educate you.  Once you've mastered that move on to the IEEE studies, look up Grid Computing, read about Blue Gene etc.
1143658
Multiple threads can be executed in parallel on many computer systems. This multithreading generally occurs by time slicing, wherein a single processor switches between different threads--in which case the processing is not literally "simultaneous", for the single processor is only really doing one thing at a time (though this switching can happen so fast as to give the illusion of simultaneity). On a multiprocessor system, threading can be achieved via multiprocessing, wherein different threads can run simultaneously on different processors.\n\nMany modern operating systems directly support both time-sliced and multiprocessor threading with a process scheduler. The operating system kernel allows programmers to manipulate threads via the system call interface. Some implementations are called a kernel thread, whereas a lightweight process is a specific type of kernel thread that shares the same state and information.\n\nAbsent that, programs can still implement threading by using timers, signals, or other methods to interrupt their own execution and hence perform a sort of ad hoc time-slicing. These are sometimes called user-space threads.\n\nAn unrelated use of the term thread is for threaded code, which is a form of code consisting entirely of subroutine calls, written without the subroutine call instruction, and processed by an interpreter or the CPU. Two threaded code languages are Forth and early B programming languages.\nMultithreading is a popular programming and execution model that allows multiple threads to exist within the context of a single process, sharing the process' resources but able to execute independently. The threaded programming model provides developers with a useful abstraction of concurrent execution. However, perhaps the most interesting application of the technology is when it is applied to a single process to enable parallel execution on a multiprocessor system.\n\nThe term multiprocessing is sometimes used to refer to the execution of multiple concurrent software processes in a system as opposed to a single process at any one instant. However, the term multiprogramming is more appropriate to describe this concept, which is implemented mostly in software, whereas multiprocessing is more appropriate to describe the use of multiple hardware CPUs. A system can be both multiprocessing and multiprogramming, only one of the two, or neither of the two.
1023405
Not that I know of. I use good old C++ to do molty threading and dual core programing. I wish they would come up with one I am tired of all the extra work needed to lock resources.
553841
In a nutshell, a process can contain multiple threads. \n\nIn most multithreading operating systems, a process gets its own memory address space; a thread doesn't. Threads typically share the heap belonging to their parent process. \n\nFor instance, a JVM runs in a single process in the host O/S. Threads in the JVM share the heap belonging to that process; that's why several threads may access the same object. \n\nTypically, even though they share a common heap, threads have their own stack space. This is how one thread's invocation of a method is kept separate from another's. \n\nThis is all a gross oversimplification, but it's accurate enough at a high level. Lots of details differ between operating systems. \n\nWith love
263045
Date: 5/1/2004 12:00:00 AM\n\nC# .Net Tutorial Multithreading\n   Any Windows application must have one or more processes. A Process is structural unit with a memory block and using some set of resources. For each executable, the Windows operating system creates some isolated memory block. This C# .Net Tutorial tries to explain the basics of Multithreading in C# .Net.\n\n   Every process must have at least one thread. The first thread is created with a process and is known as primary thread. This Primary Thread is entry point of application. In traditional Windows applications it is the method WinMain() and in console applications it is named main().\n\n   Main goal of creating multithreading application is performance improvement. As an example, imagine a situation where in a user starts a long process (e.g. copying), he can?t use a single threaded application and wait for an infinite time for the operation to get completed. But if he uses multi?threading application he can set copying process in the background and interact with application without any problems.\n\n   At first, if one wants to create a multi-threaded application an important point to be remembered is, a global variable, which is being accessed by different threads, can try to modify the same variable. This is a generic problem, which is solved using a mechanism called Synchronization of threads. Synchronization is nothing but the process of creating some set of rules to operate data or resources.\n\n   The C# .Net language has a powerful namespace which can be used for programming with Threads as well as Thread Synchronization in C# .Net programming. The name of the namespace is Sytem.Threading. The most important class inside this namespace for manipulating the threads is the C# .Net class Thread. It can run other thread in our application process.\n\nSample program on C# Multithreading - C# Tutorial:\n   The example it creates an additional C# .Net class Launcher. It has only one method, which output countdown in the console.\n\n\n--------------------------------------------------------------------------------\n\n//Sample for C# tutorial on Multithreading using lock\n\npublic void Coundown()\n{\n\nlock(this)\n{\n\nfor(int i=4;i>=0;i--)\n{\n\n    Console.WriteLine("{0} seconds to start",i);\n\n}\n\nConsole.WriteLine("GO!!!!!");\n\n}\n\n} \n\n\n--------------------------------------------------------------------------------\n\n\n   There is a new keyword lock inside the above chunk of .Net C# tutorial code. This provides a mechanism for synchronizing the thread operation. It means at the same point of time only one thread can access to this method of created object. Unless the lock is released after completion of the code, the next routine or iteration cannot enter the block.\n\n   To understand it more clearly please have a look at the piece of main method?s code:\n\n\n--------------------------------------------------------------------------------\n\nLauncher la = new Launcher();\n\nThread firstThread = new Thread(new ThreadStart(la.Coundown));\nThread secondThread =new Thread(new ThreadStart(la.Coundown));\nThread thirdThread = new Thread(new ThreadStart(la.Coundown));\n\nfirstThread.Start();\nsecondThread.Start();\nthirdThread.Start();\n\n\n--------------------------------------------------------------------------------\n\n\n   As you see there were created three additional threads. These threads start a method of object that has Launcher type. The above program is a very simple example of using multi-threading in C#. Net. But C# .Net allows us to create more powerful applications with any level of complexity
914482
There are thousands of people involved in tweaking, discussing, doing research on algorithms, and changing the Linux kernel.  They have held conventions just for the developers. (www.linuxsymposium.org)\n\n Linux's kernel is one of the most studied pieces of code ont he planet, and it has many revisions and variations.  Since the code is free to read and use by the world, the kernel gets used in many dedicated projects for specialized endeavors.\n\n These are active developers.  The number of final hands an "approved change" goes through is smaller (www.kernel.org) but overall, many people have contributed to it over time.
642888
Use SWT, they are already multithreaded and with ease you could do such thing.
705477
You have a lot to learn about the difference between these  three. I'll give the basic differences. In all these three there are more than one program executing at a time. But...\n\nMultiprograming: In multiprogramming systems, the running task keeps running until it performs an operation that requires waiting for an external event (e.g. reading from a tape) or until the computer's scheduler forcibly swaps the running task out of the CPU. Multiprogramming systems are designed to maximize CPU usage.\n\nMultitasking: In computing, multitasking is a method by which multiple tasks, also known as processes, share common processing resources such as a CPU. In the case of a computer with a single CPU, only one task is said to be running at any point in time, meaning that the CPU is actively executing instructions for that task. Multitasking solves the problem by scheduling which task may be the one running at any given time, and when another waiting task gets a turn. The act of reassigning a CPU from one task to another one is called a context switch.\n\nMultiprocessing: Multiprocessing is a generic term for the use of two or more central processing units (CPUs) within a single computer system. There are many variations on this basic theme, and the definition of multiprocessing can vary with context, mostly as a function of how CPUs are defined (multiple cores on one die, multiple chips in one package, multiple packages in one system unit, etc.).\n\nMultiprocessing sometimes refers to the execution of multiple concurrent software processes in a system as opposed to a single process at any one instant.\n\nOk? :)
528808
It purely depends upon the programming language u use\n\nThe following is in C#\nThread.CurrentThread.Name = "Main thread";\nClass1 obj = new Class1();\nThread thread = new Thread(\nnew ThreadStart(obj.ThreadStart));\nthread.Name = "Forked thread";\n\nNow in Java\nJava's creators have graciously designed two ways of creating threads: implementing an interface and extending a class. Extending a class is the way Java inherits methods and variables from a parent class. In this case, one can only extend or inherit from a single parent class. This limitation within Java can be overcome by implementing interfaces, which is the most common way to create threads\nthread.Start();\n\nimport java.lang.*;\npublic class Counter extends Thread \n{                      \n        public void run()                       \n        {              \n        ....            \n        }\n}\n\nand\n\nimport java.lang.*;\npublic class Counter implements Runnable\n{\n        Thread T;                        \n        public void run()                       \n        {                              \n        ....            \n        }\n}
840168
In computing, the kernel is the central component of most computer operating systems (OSs). Its responsibilities include managing the system's resources and the communication between hardware and software components. As a basic component of an operating system, a kernel provides the lowest level of abstraction layer for the resources (especially memory, processors and I/O devices) that applications must control to perform their function. It typically makes these facilities available to application processes through inter-process communication mechanisms and system calls.\n\nThese tasks are done differently by different kernels, depending on their design and implementation. While monolithic kernels will try to achieve these goals by executing all the code in the same address space to increase the performance of the system, microkernels run most of their services in user space, aiming to improve maintainability and modularity of the codebase. A range of possibilities exists between these two extremes.\n\nclick here:http://en.wikipedia.org/wiki/Kernel_%28computer_science%29#Overview