VPython Multithreading: Difference between revisions
No edit summary |
|||
(27 intermediate revisions by 2 users not shown) | |||
Line 18: | Line 18: | ||
==Implementation== | |||
===Threading Library=== | |||
*threading.currentThread() | |||
::Returns the count of threads under the control of the caller | |||
*threading.activeCount() | |||
::Returns the count of total active threads | |||
*threading.enumerate() | |||
::Returns a list of all active threads as Thread objects | |||
=== | ===Thread instance methods=== | ||
*run() | |||
::Method for the starting point of a thread | |||
*start() | |||
::Calls the run method of a thread | |||
*getName() | |||
::Returns the name of a thread | |||
*setName() | |||
::Sets the name of a thread | |||
*isAlive() | |||
::Boolean value indicating whether the thread is still running or not | |||
*join() | |||
::Function that waits for other threads to terminate before continuing | |||
===Thread Creation=== | |||
Creating a thread is a 3 step process. | |||
# Create a Thread object with a target | |||
# Cache your thread for maintenance | |||
# Start your thread | |||
== | <code> | ||
:import threading | |||
: | |||
:def ourTarget(): | |||
::print 'Thread Started' | |||
::return | |||
: | |||
:threads = [] | |||
:t = threading.thread(target=ourTarget) | |||
:threads.append(t) | |||
:t.start() | |||
</code> | |||
===Thread Synchronization=== | |||
Thread synchronization is the process of waiting for another thread to complete before proceeding. For instance, you may not want to begin rending objects on screen until a certain computation or input is received. You may also want to wait for all threads to finish executing before terminating your program. | |||
=== | : | ||
=== | In python, we use the instance method "join" to tell a thread to wait for the completion of others. | ||
== | : | ||
<code> | |||
:import threading | |||
:from random import randrange | |||
: | |||
:def ourTarget(): | |||
::print 'Thread Started' | |||
::for i in range(randrange(100,10000)): | |||
:::ball = sphere(pos=vector(0,0,0), color=color.red, radius = randrange(0, 100)) | |||
::return | |||
: | |||
:threads = [] | |||
:for i in range(20): | |||
::t = threading.thread(target=ourTarget) | |||
::threads.append(t) | |||
::t.start() | |||
:for t in threads: | |||
::t.join() | |||
:print 'All threads finished' | |||
</code> | |||
==Connectedness== | ==Connectedness== | ||
#How is this topic connected to something that you are interested in? | #How is this topic connected to something that you are interested in? | ||
::::With coding, I know first hand that better performance is often needed--especially when running complex simulations. I thought it would be fun to demonstrate multithreading in relation to VPython. | |||
#How is it connected to your major? | #How is it connected to your major? | ||
::::As a CS major, I spend a lot of my time coding. I run into situations that need multithreading quite often. | |||
#Is there an interesting industrial application? | #Is there an interesting industrial application? | ||
::::Yes! Almost every commercial application needs multithreading! It's a core requirement to when working on applications that are nontrivial! | |||
==History== | ==History== | ||
Multithreading first appeared in 1967 in OS/360 Multiprogramming with a Variable Number of Tasks or MVT. This time-sliced system allowed "tasks" to be run simultaneously. Timesharing at this point referred to multiple users sharing a single machine at different times. This MVT, however, allowed for a new definition of timesharing applications.[https://en.wikipedia.org/wiki/OS/360_and_successors#MVT] | |||
== See also == | == See also == | ||
[http://www.physicsbook.gatech.edu/VPython VPython Intro] | |||
[http://www.physicsbook.gatech.edu/VPython_basics VPython Basics] | |||
===External links=== | ===External links=== | ||
[ | [https://docs.python.org/2/library/threading.html Python Official Threading Docs] | ||
[https://docs.python.org/3/library/threading.html Python Thread Based Parallelism] | |||
==References== | ==References== | ||
Line 60: | Line 113: | ||
This section contains the the references you used while writing this page | This section contains the the references you used while writing this page | ||
[[Category: | [[Category:VPython]] |
Latest revision as of 17:09, 4 December 2015
Claimed by Philip Bale
Here we discuss multithreading as it relates to advanced VPython physics computations
Overview
Multithreading is the ability to execute multiple processes (or threads) concurrently. Instead of a single execution flow, multiple program paths may be followed at once. With multithreading, programs may no longer be executed strictly in a linear manner. The notion of multithreaded parallelism in computing is similar to multitasking in real life--the idea is to get more done at once.
Multithreading is very important to VPython. Imagine a Solar System model. Though it would be possible to model and update the entire system in a linear fashion, when it comes to movement and animation, the computation can get incredibly intense. Since your computer shares it's process cycles with various other programs, you may notice significant lag while trying to achieve your task. Multithreading, however, would allow you to model and update each Planet (or even subsystems of a planet, etc.) concurrently. For a system of thousands of relevant objects, the speed improvement could be many orders of magnitude with multithreading.
As an analogy, think of multithreading as a single employee vs. an assembly line. A car could simply be worked on by a singular person. It may also, however, be worked on by multiple people performing their own tasks at the same time. The idea of multiple tasks being executed at the same time is the essence of multithreading.
Advantages
Multithreading allows advanced and complex computations to be performed more efficiently due to concurrency. The asynchronous potential of multithreaded programs supports smoother graphical renderings and more accurate user input as well. While one thread is performing mathematical computations, another could be rendering models on screen, while another is taking user input. The modularity of threading allows users to break down processes as they see fit. Furthermore, various threads may share global objects. This allows for mutual cooperation and sharing when necessary. Threads are also light-weight and cheaper than processes. Since threads can be interrupted and put on hold, they also afford a good amount of flexibility.
Disadvantages
With multithreading comes risks and disadvantage--though not to be thought as zero-sum. There are cases when breaking up a single process into multiple threads is more costly due to memory and resource allocations. From a programming standpoint, multithreaded applications are also more complex in terms of time and logic. Thread scheduling can also cause program locks if not executed correctly.
Implementation
Threading Library
- threading.currentThread()
- Returns the count of threads under the control of the caller
- threading.activeCount()
- Returns the count of total active threads
- threading.enumerate()
- Returns a list of all active threads as Thread objects
Thread instance methods
- run()
- Method for the starting point of a thread
- start()
- Calls the run method of a thread
- getName()
- Returns the name of a thread
- setName()
- Sets the name of a thread
- isAlive()
- Boolean value indicating whether the thread is still running or not
- join()
- Function that waits for other threads to terminate before continuing
Thread Creation
Creating a thread is a 3 step process.
- Create a Thread object with a target
- Cache your thread for maintenance
- Start your thread
- import threading
- def ourTarget():
- print 'Thread Started'
- return
- threads = []
- t = threading.thread(target=ourTarget)
- threads.append(t)
- t.start()
Thread Synchronization
Thread synchronization is the process of waiting for another thread to complete before proceeding. For instance, you may not want to begin rending objects on screen until a certain computation or input is received. You may also want to wait for all threads to finish executing before terminating your program.
In python, we use the instance method "join" to tell a thread to wait for the completion of others.
- import threading
- from random import randrange
- def ourTarget():
- print 'Thread Started'
- for i in range(randrange(100,10000)):
- ball = sphere(pos=vector(0,0,0), color=color.red, radius = randrange(0, 100))
- return
- threads = []
- for i in range(20):
- t = threading.thread(target=ourTarget)
- threads.append(t)
- t.start()
- for t in threads:
- t.join()
- print 'All threads finished'
Connectedness
- How is this topic connected to something that you are interested in?
- With coding, I know first hand that better performance is often needed--especially when running complex simulations. I thought it would be fun to demonstrate multithreading in relation to VPython.
- How is it connected to your major?
- As a CS major, I spend a lot of my time coding. I run into situations that need multithreading quite often.
- Is there an interesting industrial application?
- Yes! Almost every commercial application needs multithreading! It's a core requirement to when working on applications that are nontrivial!
History
Multithreading first appeared in 1967 in OS/360 Multiprogramming with a Variable Number of Tasks or MVT. This time-sliced system allowed "tasks" to be run simultaneously. Timesharing at this point referred to multiple users sharing a single machine at different times. This MVT, however, allowed for a new definition of timesharing applications.[1]
See also
External links
Python Official Threading Docs
Python Thread Based Parallelism
References
This section contains the the references you used while writing this page